prevent crash when removing remote with no urls

2026-10-03 20:46:47 -04:00 · 2020-11-05 20:16:08 +11:00
3515 changed files with 39795 additions and 114420 deletions
@@ -1,9 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "gomod"
-    directory: "/"
-    schedule:
-      interval: "weekly"
-    allowed_updates:
-      - match:
-          update_type: "security"
@@ -6,8 +6,8 @@ on:
      - 'v*'

 jobs:
-  goreleaser:
-    runs-on: ubuntu-latest
+  cd:
+    runs-on: ubuntu-20.04
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
@@ -16,16 +16,30 @@ jobs:
      - name: Setup Go
        uses: actions/setup-go@v1
        with:
-          go-version: 1.16.x
+          go-version: 1.14.x
      - name: Run goreleaser
        uses: goreleaser/goreleaser-action@v1
        env:
          GITHUB_TOKEN: ${{secrets.GITHUB_API_TOKEN}}
-  homebrew:
-    runs-on: macos-latest
-    steps:
-      - name: Bump Homebrew formula
+      - name: Bump Homebrew
        uses: dawidd6/action-homebrew-bump-formula@v3
        with:
          token: ${{secrets.GITHUB_API_TOKEN}}
          formula: lazygit
+      - name: Checkout PPA repo
+        uses: actions/checkout@v2
+        with:
+          repository: dawidd6/lazygit-debian
+          token: ${{secrets.GITHUB_API_TOKEN}}
+          fetch-depth: 0
+      - name: Update PPA repo
+        run: |
+          version="$(echo "$GITHUB_REF" | sed 's@refs/tags/v@@')"
+          sudo apt install -y git-buildpackage
+          git fetch --tags https://github.com/$GITHUB_REPOSITORY
+          gbp import-ref -u "$version"
+          gbp dch -D xenial -N "$version"-1
+          git add debian/changelog
+          git commit -m "d/changelog: dch $version"
+          gbp tag
+          git push --tags origin master
@@ -8,58 +8,33 @@ on:

 jobs:
  ci:
-    strategy:
-      fail-fast: false
-      matrix:
-        os:
-          - ubuntu-latest
-          - windows-latest
-    name: ci - ${{matrix.os}}
-    runs-on: ${{matrix.os}}
-    env:
-      GOFLAGS: -mod=vendor
-    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')}}-test
-          restore-keys: |
-            ${{runner.os}}-go-
-      - name: Test code
-        run: |
-          bash ./test.sh
-  build:
    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
+          go-version: 1.14.x
      - name: Cache build
        uses: actions/cache@v1
        with:
          path: ~/.cache/go-build
-          key: ${{runner.os}}-go-${{hashFiles('**/go.sum')}}-build
+          key: ${{runner.os}}-go-${{hashFiles('**/go.sum')}}
          restore-keys: |
            ${{runner.os}}-go-
-      - name: Build linux binary
+      - name: Format code
        run: |
-          GOOS=linux go build
-      - name: Build windows binary
+          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: Test code
        run: |
-          GOOS=windows go build
-      - name: Build darwin binary
-        run: |
-          GOOS=darwin go build
+          ./test.sh
+      - name: Build binaries
+        uses: goreleaser/goreleaser-action@v1
+        with:
+          args: --skip-publish --snapshot
@@ -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
@@ -27,10 +27,7 @@ lazygit

 test/git_server/data
 test/integration/*/actual/
-test/integration/*/actual_remote/
 test/integration/*/used_config/
-# these sample hooks waste too much space
+# these sample hooks waste too space space
 test/integration/*/expected/.git_keep/hooks/
-test/integration/*/expected_remote/hooks/
 !.git_keep/
-lazygit.exe
@@ -1,13 +1,14 @@
 # Contributing

+
 ♥ We love pull requests from everyone !

+
 When contributing to this repository, please first discuss the change you wish
 to make via issue, email, or any other method with the owners of this repository
-before making a change.
+before making a change. 

 ## So all code changes happen through Pull Requests
-
 Pull requests are the best way to propose changes to the codebase. We actively
 welcome your pull requests:

@@ -20,33 +21,15 @@ welcome your pull requests:
 7. Issue that pull request!

 ## Code of conduct
-
 Please note by participating in this project, you agree to abide by the [code of conduct].

 [code of conduct]: https://github.com/jesseduffield/lazygit/blob/master/CODE-OF-CONDUCT.md

 ## Any contributions you make will be under the MIT Software License
-
 In short, when you submit code changes, your submissions are understood to be
 under the same [MIT License](http://choosealicense.com/licenses/mit/) that
 covers the project. Feel free to contact the maintainers if that's a concern.

 ## Report bugs using Github's [issues](https://github.com/jesseduffield/lazygit/issues)
-
 We use GitHub issues to track public bugs. Report a bug by [opening a new
 issue](https://github.com/jesseduffield/lazygit/issues/new); it's that easy!
-
-## Updating Gocui
-
-Sometimes you will need to make a change in the gocui fork (https://github.com/jesseduffield/gocui). Gocui is the package responsible for rending windows and handling user input. Here's the typical process to follow:
-
-1. Make the changes in gocui inside the vendor directory so it's easy to test against lazygit
-2. Copy the changes over to the actual gocui repo (clone it if you haven't already, and use the `awesome` branch, not `master`)
-3. Raise a PR on the gocui repo with your changes
-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
-```
-
-5. Raise a PR in lazygit with those changes
@@ -21,6 +21,7 @@ If you're a mere mortal like me and you're tired of hearing how powerful git is
  - [Binary releases](#binary-releases)
  - [Homebrew](#homebrew)
  - [MacPorts](#macports)
+  - [Ubuntu](#ubuntu)
  - [Void Linux](#void-linux)
  - [Scoop (Windows)](#scoop-windows)
  - [Arch Linux](#arch-linux)
@@ -29,7 +30,6 @@ If you're a mere mortal like me and you're tired of hearing how powerful git is
  - [FreeBSD](#freebsd)
  - [Conda](#conda)
  - [Go](#go)
-  - [Chocolatey (Windows)](#chocolatey-windows)
  - [Manual](#manual)
 - [Usage](#usage)
  - [Keybindings](#keybindings)
@@ -52,7 +52,7 @@ Github Sponsors is matching all donations dollar-for-dollar for 12 months so if

 ### Binary Releases

-For Windows, Mac OS(10.12+) or Linux, you can download a binary release [here](../../releases).
+For Windows, Mac OS or Linux, you can download a binary release [here](../../releases).

 ### Homebrew

@@ -81,8 +81,6 @@ sudo port install lazygit

 ### Ubuntu

-**Deprecated**: will no longer receive updates.
-
 Packages for Ubuntu are available via [Launchpad PPA](https://launchpad.net/~lazygit-team).

 ```sh
@@ -115,12 +113,12 @@ scoop install lazygit

 ### Arch Linux

-Packages for Arch Linux are available via pacman and AUR (Arch User Repository).
+Packages for Arch Linux are available via AUR (Arch User Repository).

 There are two packages. The stable one which is built with the latest release
 and the git version which builds from the most recent commit.

- Stable: `sudo pacman -S lazygit`
+- Stable: <https://aur.archlinux.org/packages/lazygit/>
 - Development: <https://aur.archlinux.org/packages/lazygit-git/>

 Instruction of how to install AUR content can be found here:
@@ -168,14 +166,6 @@ may need to add `~/go/bin` to your \$PATH (MacOS/Linux), or `%HOME%\go\bin`
 (Windows). Not to be mistaked for `C:\Go\bin` (which is for Go's own binaries,
 not apps like Lazygit).

-### Chocolatey (Windows)
-
-You can install `lazygit` using [Chocolatey](https://chocolatey.org/):
-
-```sh
-choco install lazygit
-```
-
 ### Manual

 You'll need to [install Go](https://golang.org/doc/install)
@@ -280,10 +270,12 @@ Run `lazygit --debug` in one terminal tab and `lazygit --logs` in another to vie

 If you would like to support the development of lazygit, consider [sponsoring me](https://github.com/sponsors/jesseduffield) (github is matching all donations dollar-for-dollar for 12 months)

-## FAQ
+## Work in progress

-### I'm struggling to see the selected line
-see [here](https://github.com/jesseduffield/lazygit/blob/master/docs/Config.md#struggling-to-see-selected-line)
+This is still a work in progress so there's still bugs to iron out and as this
+is my first project in Go the code could no doubt use an increase in quality,
+but I'll be improving on it whenever I find the time. If you have any feedback
+feel free to [raise an issue](https://github.com/jesseduffield/lazygit/issues)/[submit a PR](https://github.com/jesseduffield/lazygit/pulls).

 ## Social

@@ -1,5 +0,0 @@
-# Go's proxy servers are not very up-to-date so that's why we use `GOPROXY=direct`
-# We specify the `awesome` branch to avoid the default behaviour of looking for a semver tag.
-GOPROXY=direct go get -u github.com/jesseduffield/gocui@awesome && go mod vendor && go mod tidy
-
-# Note to self if you ever want to fork a repo be sure to use this same approach: it's important to use the branch name (e.g. master)
@@ -2,219 +2,176 @@

 Default path for the config file:

- Linux: `~/.config/lazygit/config.yml`
- MacOS: `~/Library/Application Support/lazygit/config.yml`
- Windows: `%APPDATA%\lazygit\config.yml`
-
-For old installations (slightly embarrassing: I didn't realise at the time that you didn't need to supply a vendor name to the path so I just used my name):
-
- Linux: `~/.config/jesseduffield/lazygit/config.yml`
- MacOS: `~/Library/Application Support/jesseduffield/lazygit/config.yml`
- Windows: `%APPDATA%\jesseduffield\lazygit\config.yml`
+* Linux: `~/.config/jesseduffield/lazygit/config.yml`
+* MacOS: `~/Library/Application Support/jesseduffield/lazygit/config.yml`
+* Windows: `%APPDATA%\jesseduffield\lazygit\config.yml`

 ## Default

 ```yaml
-gui:
-  # stuff relating to the UI
-  scrollHeight: 2 # how many lines you scroll by
-  scrollPastBottom: true # enable scrolling past the bottom
-  sidePanelWidth: 0.3333 # number from 0 to 1
-  expandFocusedSidePanel: false
-  mainPanelSplitMode: 'flexible' # one of 'horizontal' | 'flexible' | 'vertical'
-  language: 'auto' # one of 'auto' | 'en' | 'zh' | 'pl' | 'nl'
-  theme:
-    lightTheme: false # For terminals with a light background
-    activeBorderColor:
-      - white
-      - bold
-    inactiveBorderColor:
-      - green
-    optionsTextColor:
-      - blue
-    selectedLineBgColor:
-      - default
-    selectedRangeBgColor:
-      - blue
-    cherryPickedCommitBgColor:
-      - blue
-    cherryPickedCommitFgColor:
-      - cyan
-  commitLength:
-    show: true
-  mouseEvents: true
-  skipUnstageLineWarning: false
-  skipStashWarning: true
-  showFileTree: false # for rendering changes files in a tree format
-  showListFooter: true # for seeing the '5 of 20' message in list panels
-  showRandomTip: true
-  showCommandLog: true
-  commandLogSize: 8
-  authorColors: # in case you're not happy with the randomly assigned colour
-    'John Smith': '#ff0000'
-git:
-  paging:
-    colorArg: always
-    useConfig: false
-  merging:
-    # only applicable to unix users
-    manualCommit: false
-    # extra args passed to `git merge`, e.g. --no-ff
-    args: ''
-  log:
-    # one of date-order, author-date-order, topo-order.
-    # topo-order makes it easier to read the git log graph, but commits may not
-    # appear chronologically. See https://git-scm.com/docs/git-log#_commit_ordering
-    order: 'topo-order'
-    # one of always, never, when-maximised
-    # this determines whether the git graph is rendered in the commits panel
-    showGraph: 'when-maximised'
-  skipHookPrefix: WIP
-  autoFetch: true
-  branchLogCmd: 'git log --graph --color=always --abbrev-commit --decorate --date=relative --pretty=medium {{branchName}} --'
-  allBranchesLogCmd: 'git log --graph --all --color=always --abbrev-commit --decorate --date=relative  --pretty=medium'
-  overrideGpg: false # prevents lazygit from spawning a separate process when using GPG
-  disableForcePushing: false
-  parseEmoji: false
-os:
-  editCommand: '' # see 'Configuring File Editing' section
-  editCommandTemplate: '{{editor}} {{filename}}'
-  openCommand: ''
-refresher:
-  refreshInterval: 10 # file/submodule refresh interval in seconds
-  fetchInterval: 60 # re-fetch interval in seconds
-update:
-  method: prompt # can be: prompt | background | never
-  days: 14 # how often an update is checked for
-reporting: 'undetermined' # one of: 'on' | 'off' | 'undetermined'
-confirmOnQuit: false
-# determines whether hitting 'esc' will quit the application when there is nothing to cancel/close
-quitOnTopLevelReturn: false
-disableStartupPopups: false
-notARepository: 'prompt' # one of: 'prompt' | 'create' | 'skip'
-keybinding:
-  universal:
-    quit: 'q'
-    quit-alt1: '<c-c>' # alternative/alias of quit
-    return: '<esc>' # return to previous menu, will quit if there's nowhere to return
-    quitWithoutChangingDirectory: 'Q'
-    togglePanel: '<tab>' # goto the next panel
-    prevItem: '<up>' # go one line up
-    nextItem: '<down>' # go one line down
-    prevItem-alt: 'k' # go one line up
-    nextItem-alt: 'j' # go one line down
-    prevPage: ',' # go to next page in list
-    nextPage: '.' # go to previous page in list
-    gotoTop: '<' # go to top of list
-    gotoBottom: '>' # go to bottom of list
-    scrollLeft: 'H' # scroll left within list view
-    scrollRight: 'L' # scroll right within list view
-    prevBlock: '<left>' # goto the previous block / panel
-    nextBlock: '<right>' # goto the next block / panel
-    prevBlock-alt: 'h' # goto the previous block / panel
-    nextBlock-alt: 'l' # goto the next block / panel
-    jumpToBlock: ['1', '2', '3', '4', '5'] # goto the Nth block / panel
-    nextMatch: 'n'
-    prevMatch: 'N'
-    optionMenu: 'x' # show help menu
-    optionMenu-alt1: '?' # show help menu
-    select: '<space>'
-    goInto: '<enter>'
-    openRecentRepos: '<c-r>'
-    confirm: '<enter>'
-    confirm-alt1: 'y'
-    remove: 'd'
-    new: 'n'
-    edit: 'e'
-    openFile: 'o'
-    scrollUpMain: '<pgup>' # main panel scroll up
-    scrollDownMain: '<pgdown>' # main panel scroll down
-    scrollUpMain-alt1: 'K' # main panel scroll up
-    scrollDownMain-alt1: 'J' # main panel scroll down
-    scrollUpMain-alt2: '<c-u>' # main panel scroll up
-    scrollDownMain-alt2: '<c-d>' # main panel scroll down
-    executeCustomCommand: ':'
-    createRebaseOptionsMenu: 'm'
-    pushFiles: 'P'
-    pullFiles: 'p'
-    refresh: 'R'
-    createPatchOptionsMenu: '<c-p>'
-    nextTab: ']'
-    prevTab: '['
-    nextScreenMode: '+'
-    prevScreenMode: '_'
-    undo: 'z'
-    redo: '<c-z>'
-    filteringMenu: '<c-s>'
-    diffingMenu: 'W'
-    diffingMenu-alt: '<c-e>' # deprecated
-    copyToClipboard: '<c-o>'
-    submitEditorText: '<enter>'
-    appendNewline: '<a-enter>'
-    extrasMenu: '@'
-    toggleWhitespaceInDiffView: '<c-w>'
-  status:
-    checkForUpdate: 'u'
-    recentRepos: '<enter>'
-  files:
-    commitChanges: 'c'
-    commitChangesWithoutHook: 'w' # commit changes without pre-commit hook
-    amendLastCommit: 'A'
-    commitChangesWithEditor: 'C'
-    ignoreFile: 'i'
-    refreshFiles: 'r'
-    stashAllChanges: 's'
-    viewStashOptions: 'S'
-    toggleStagedAll: 'a' # stage/unstage all
-    viewResetOptions: 'D'
-    fetch: 'f'
-    toggleTreeView: '`'
-  branches:
-    createPullRequest: 'o'
-    viewPullRequestOptions: 'O'
-    checkoutBranchByName: 'c'
-    forceCheckoutBranch: 'F'
-    rebaseBranch: 'r'
-    mergeIntoCurrentBranch: 'M'
-    viewGitFlowOptions: 'i'
-    fastForward: 'f' # fast-forward this branch from its upstream
-    pushTag: 'P'
-    setUpstream: 'u' # set as upstream of checked-out branch
-    fetchRemote: 'f'
-  commits:
-    squashDown: 's'
-    renameCommit: 'r'
-    renameCommitWithEditor: 'R'
-    viewResetOptions: 'g'
-    markCommitAsFixup: 'f'
-    createFixupCommit: 'F' # create fixup commit for this commit
-    squashAboveCommits: 'S'
-    moveDownCommit: '<c-j>' # move commit down one
-    moveUpCommit: '<c-k>' # move commit up one
-    amendToCommit: 'A'
-    pickCommit: 'p' # pick commit (when mid-rebase)
-    revertCommit: 't'
-    cherryPickCopy: 'c'
-    cherryPickCopyRange: 'C'
-    pasteCommits: 'v'
-    tagCommit: 'T'
-    checkoutCommit: '<space>'
-    resetCherryPick: '<c-R>'
-    copyCommitMessageToClipboard: '<c-y>'
-    openLogMenu: '<c-l>'
-  stash:
-    popStash: 'g'
-  commitFiles:
-    checkoutCommitFile: 'c'
-  main:
-    toggleDragSelect: 'v'
-    toggleDragSelect-alt: 'V'
-    toggleSelectHunk: 'a'
-    pickBothHunks: 'b'
-  submodules:
-    init: 'i'
-    update: 'u'
-    bulkMenu: 'b'
+  gui:
+    # stuff relating to the UI
+    scrollHeight: 2 # how many lines you scroll by
+    scrollPastBottom: true # enable scrolling past the bottom
+    sidePanelWidth: 0.3333 # number from 0 to 1
+    expandFocusedSidePanel: false
+    mainPanelSplitMode: 'flexible' # one of 'horizontal' | 'flexible' | 'vertical'
+    theme:
+      lightTheme: false # For terminals with a light background
+      activeBorderColor:
+        - white
+        - bold
+      inactiveBorderColor:
+        - green
+      optionsTextColor:
+        - blue
+      selectedLineBgColor:
+        - default
+      selectedRangeBgColor:
+        - blue
+    commitLength:
+      show: true
+    mouseEvents: true
+    skipUnstageLineWarning: false
+    skipStashWarning: true
+  git:
+    paging:
+      colorArg: always
+      useConfig: false
+    merging:
+      # only applicable to unix users
+      manualCommit: false
+      # extra args passed to `git merge`, e.g. --no-ff
+      args: ""
+    pull:
+      mode: 'merge' # one of 'merge' | 'rebase' | 'ff-only'
+    skipHookPrefix: WIP
+    autoFetch: true
+    branchLogCmd: "git log --graph --color=always --abbrev-commit --decorate --date=relative --pretty=medium {{branchName}} --"
+    overrideGpg: false # prevents lazygit from spawning a separate process when using GPG
+    disableForcePushing: false
+  update:
+    method: prompt # can be: prompt | background | never
+    days: 14 # how often an update is checked for
+  reporting: 'undetermined' # one of: 'on' | 'off' | 'undetermined'
+  confirmOnQuit: false
+  # determines whether hitting 'esc' will quit the application when there is nothing to cancel/close
+  quitOnTopLevelReturn: true
+  disableStartupPopups: false
+  keybinding:
+    universal:
+      quit: 'q'
+      quit-alt1: '<c-c>' # alternative/alias of quit
+      return: '<esc>' # return to previous menu, will quit if there's nowhere to return
+      quitWithoutChangingDirectory: 'Q'
+      togglePanel: '<tab>' # goto the next panel
+      prevItem: '<up>' # go one line up
+      nextItem: '<down>' # go one line down
+      prevItem-alt: 'k' # go one line up
+      nextItem-alt: 'j' # go one line down
+      prevPage: ',' # go to next page in list
+      nextPage: '.' # go to previous page in list
+      gotoTop: '<' # go to top of list
+      gotoBottom: '>' # go to bottom of list
+      prevBlock: '<left>' # goto the previous block / panel
+      nextBlock: '<right>' # goto the next block / panel
+      prevBlock-alt: 'h' # goto the previous block / panel
+      nextBlock-alt: 'l' # goto the next block / panel
+      nextMatch: 'n'
+      prevMatch: 'N'
+      optionMenu: 'x' # show help menu
+      optionMenu-alt1: '?' # show help menu
+      select: '<space>'
+      goInto: '<enter>'
+      confirm: '<enter>'
+      confirm-alt1: 'y'
+      remove: 'd'
+      new: 'n'
+      edit: 'e'
+      openFile: 'o'
+      scrollUpMain: '<pgup>' # main panel scrool up
+      scrollDownMain: '<pgdown>' # main panel scrool down
+      scrollUpMain-alt1: 'K' # main panel scrool up
+      scrollDownMain-alt1: 'J' # main panel scrool down
+      scrollUpMain-alt2: '<c-u>' # main panel scrool up
+      scrollDownMain-alt2: '<c-d>' # main panel scrool down
+      executeCustomCommand: ':'
+      createRebaseOptionsMenu: 'm'
+      pushFiles: 'P'
+      pullFiles: 'p'
+      refresh: 'R'
+      createPatchOptionsMenu: '<c-p>'
+      nextTab: ']'
+      prevTab: '['
+      nextScreenMode: '+'
+      prevScreenMode: '_'
+      undo: 'z'
+      redo: '<c-z>'
+      filteringMenu: '<c-s>'
+      diffingMenu: 'W'
+      diffingMenu-alt: '<c-e>' # deprecated
+      copyToClipboard: '<c-o>'
+      submitEditorText: '<enter>'
+      appendNewline: '<tab>'
+    status:
+      checkForUpdate: 'u'
+      recentRepos: '<enter>'
+    files:
+      commitChanges: 'c'
+      commitChangesWithoutHook: 'w' # commit changes without pre-commit hook
+      amendLastCommit: 'A'
+      commitChangesWithEditor: 'C'
+      ignoreFile: 'i'
+      refreshFiles: 'r'
+      stashAllChanges: 's'
+      viewStashOptions: 'S'
+      toggleStagedAll: 'a' # stage/unstage all
+      viewResetOptions: 'D'
+      fetch: 'f'
+    branches:
+      createPullRequest: 'o'
+      checkoutBranchByName: 'c'
+      forceCheckoutBranch: 'F'
+      rebaseBranch: 'r'
+      mergeIntoCurrentBranch: 'M'
+      viewGitFlowOptions: 'i'
+      fastForward: 'f' # fast-forward this branch from its upstream
+      pushTag: 'P'
+      setUpstream: 'u' # set as upstream of checked-out branch
+      fetchRemote: 'f'
+    commits:
+      squashDown: 's'
+      renameCommit: 'r'
+      renameCommitWithEditor: 'R'
+      viewResetOptions: 'g'
+      markCommitAsFixup: 'f'
+      createFixupCommit: 'F' # create fixup commit for this commit
+      squashAboveCommits: 'S'
+      moveDownCommit: '<c-j>' # move commit down one
+      moveUpCommit: '<c-k>' # move commit up one
+      amendToCommit: 'A'
+      pickCommit: 'p' # pick commit (when mid-rebase)
+      revertCommit: 't'
+      cherryPickCopy: 'c'
+      cherryPickCopyRange: 'C'
+      pasteCommits: 'v'
+      tagCommit: 'T'
+      checkoutCommit: '<space>'
+      resetCherryPick: '<c-R>'
+      copyCommitMessageToClipboard: '<c-y>'
+    stash:
+      popStash: 'g'
+    commitFiles:
+      checkoutCommitFile: 'c'
+    main:
+      toggleDragSelect: 'v'
+      toggleDragSelect-alt: 'V'
+      toggleSelectHunk: 'a'
+      pickBothHunks: 'b'
+    submodules:
+      init: 'i'
+      update: 'u'
+      bulkMenu: 'b'
 ```

 ## Platform Defaults
@@ -222,73 +179,22 @@ keybinding:
 ### Windows

 ```yaml
-os:
-  openCommand: 'start "" {{filename}}'
+  os:
+    openCommand: 'cmd /c "start "" {{filename}}"'
 ```

 ### Linux

 ```yaml
-os:
-  openCommand: 'xdg-open {{filename}} >/dev/null'
+  os:
+    openCommand: 'sh -c "xdg-open {{filename}} >/dev/null"'
 ```

 ### OSX

 ```yaml
-os:
-  openCommand: 'open {{filename}}'
-```
-
-### Configuring File Editing
-
-Lazygit will edit a file with the first set editor in the following:
-
-1. config.yaml
-
-```yaml
-os:
-  editCommand: 'vim' # as an example
-```
-
-2. \$(git config core.editor)
-3. \$GIT_EDITOR
-4. \$VISUAL
-5. \$EDITOR
-6. \$(which vi)
-
-Lazygit will log an error if none of these options are set.
-
-You can specify a line number you are currently at when in the line-by-line mode.
-
-```yaml
-os:
-  editCommand: 'vim'
-  editCommandTemplate: '{{editor}} +{{line}} {{filename}}'
-```
-
-or
-
-```yaml
-os:
-  editCommand: 'code'
-  editCommandTemplate: '{{editor}} --goto {{filename}}:{{line}}'
-```
-
-`{{editor}}` in `editCommandTemplate` is replaced with the value of `editCommand`.
-
-### Overriding default config file location
-
-To override the default config directory, use `$CONFIG_DIR="~/.config/lazygit"`. This directory contains the config file in addition to some other files lazygit uses to keep track of state across sessions.
-
-To override the individual config file used, use the `--use-config-file` arg or the `LG_CONFIG_FILE` env var.
-
-If you want to merge a specific config file into a more general config file, perhaps for the sake of setting some theme-specific options, you can supply a list of comma-separated config file paths, like so:
-
-```sh
-lazygit --use-config-file=~/.base_lg_conf,~/.light_theme_lg_conf
-or
-LG_CONFIG_FILE="~/.base_lg_conf,~/.light_theme_lg_conf" lazygit
+  os:
+    openCommand: 'open {{filename}}'
 ```

 ### Recommended Config Values
@@ -296,8 +202,8 @@ LG_CONFIG_FILE="~/.base_lg_conf,~/.light_theme_lg_conf" lazygit
 for users of VSCode

 ```yaml
-os:
-  openCommand: 'code -rg {{filename}}'
+  os:
+    openCommand: 'code -rg {{filename}}'
 ```

 ## Color Attributes
@@ -305,8 +211,7 @@ os:
 For color attributes you can choose an array of attributes (with max one color attribute)
 The available attributes are:

-**Colors**
-
+- default
 - black
 - red
 - green
@@ -315,12 +220,7 @@ The available attributes are:
 - magenta
 - cyan
 - white
- '#ff00ff'
-
-**Modifiers**
-
 - bold
- default
 - reverse # useful for high-contrast
 - underline

@@ -329,50 +229,31 @@ The available attributes are:
 If you have issues with a light terminal theme where you can't read / see the text add these settings

 ```yaml
-gui:
-  theme:
-    lightTheme: true
-    activeBorderColor:
-      - black
-      - bold
-    inactiveBorderColor:
-      - black
-    selectedLineBgColor:
-      - default
+  gui:
+    theme:
+      lightTheme: true
+      activeBorderColor:
+        - black
+        - bold
+      inactiveBorderColor:
+        - black
+      selectedLineBgColor:
+        - default
 ```

 ## Struggling to see selected line

-If you struggle to see the selected line I recommend using the reverse attribute on selected lines like so:
+If you struggle to see the selected line I recomment using the reverse attribute on selected lines like so:

 ```yaml
-gui:
-  theme:
-    selectedLineBgColor:
-      - reverse
-    selectedRangeBgColor:
-      - reverse
+  gui:
+    theme:
+      selectedLineBgColor:
+        - reverse
+      selectedRangeBgColor:
+        - reverse
 ```

-The following has also worked for a couple of people:
-
-```yaml
-gui:
-  theme:
-    activeBorderColor:
-      - white
-      - bold
-    inactiveBorderColor:
-      - white
-    selectedLineBgColor:
-      - reverse
-      - blue
-```
-
-Alternatively you may have bold fonts disabled in your terminal, in which case enabling bold fonts should solve the problem.
-
-If you're still having trouble please raise an issue.
-
 ## Example Coloring

 ![border example](../../assets/colored-border-example.png)
@@ -384,33 +265,33 @@ For all possible keybinding options, check [Custom_Keybindings.md](https://githu
 ### Example Keybindings For Colemak Users

 ```yaml
-keybinding:
-  universal:
-    prevItem-alt: 'u'
-    nextItem-alt: 'e'
-    prevBlock-alt: 'n'
-    nextBlock-alt: 'i'
-    nextMatch: '='
-    prevMatch: '-'
-    new: 'k'
-    edit: 'o'
-    openFile: 'O'
-    scrollUpMain-alt1: 'U'
-    scrollDownMain-alt1: 'E'
-    scrollUpMain-alt2: '<c-u>'
-    scrollDownMain-alt2: '<c-e>'
-    undo: 'l'
-    redo: '<c-r>'
-    diffingMenu: 'M'
-    filteringMenu: '<c-f>'
-  files:
-    ignoreFile: 'I'
-  commits:
-    moveDownCommit: '<c-e>'
-    moveUpCommit: '<c-u>'
-  branches:
-    viewGitFlowOptions: 'I'
-    setUpstream: 'U'
+  keybinding:
+    universal:
+      prevItem-alt: 'u'
+      nextItem-alt: 'e'
+      prevBlock-alt: 'n'
+      nextBlock-alt: 'i'
+      nextMatch: '='
+      prevMatch: '-'
+      new: 'k'
+      edit: 'o'
+      openFile: 'O'
+      scrollUpMain-alt1: 'U'
+      scrollDownMain-alt1: 'E'
+      scrollUpMain-alt2: '<c-u>'
+      scrollDownMain-alt2: '<c-e>'
+      undo: 'l'
+      redo: '<c-r>'
+      diffingMenu: 'M'
+      filteringMenu: '<c-f>'
+    files:
+      ignoreFile: 'I'
+    commits:
+      moveDownCommit: '<c-e>'
+      moveUpCommit: '<c-u>'
+    branches:
+      viewGitFlowOptions: 'I'
+      setUpstream: 'U'
 ```

 ## Custom pull request URLs
@@ -421,7 +302,7 @@ the pull request. You can do so on your `config.yml` file using the following sy

 ```yaml
 services:
-  '<gitDomain>': '<provider>:<webDomain>'
+  "<gitDomain>": "<provider>:<webDomain>"
 ```

 Where:
@@ -431,21 +312,19 @@ Where:
 - `webDomain` is the URL where your git service exposes a web interface and APIs, e.g. `gitservice.work.com`

 ## Predefined commit message prefix
-
 In situations where certain naming pattern is used for branches and commits, pattern can be used to populate
 commit message with prefix that is parsed from the branch name.

 Example:
-
- Branch name: feature/AB-123
- Commit message: [AB-123] Adding feature
+* Branch name: feature/AB-123
+* Commit message: [AB-123] Adding feature

 ```yaml
-git:
-  commitPrefixes:
-    my_project: # This is repository folder name
-      pattern: "^\\w+\\/(\\w+-\\w+).*"
-      replace: '[$1] '
+  git:
+    commitPrefixes:
+      my_project: # This is repository folder name
+        pattern: "^\\w+\\/(\\w+-\\w+)"
+        replace: "[$1] "
 ```

 ## Custom git log command
@@ -460,24 +339,3 @@ git:
 Result:

 ![](https://i.imgur.com/Nibq35B.png)
-
-## Launching not in a repository behaviour
-
-By default, when launching lazygit from a directory that is not a repository,
-you will be prompted to choose if you would like to initialize a repo. You can
-override this behaviour in the config with one of the following:
-
-```yaml
-# for default prompting behaviour
-notARepository: 'prompt'
-```
-
-```yaml
-# to skip and initialize a new repo
-notARepository: 'create'
-```
-
-```yaml
-# to skip without creating a new repo
-notARepository: 'skip'
-```
@@ -2,7 +2,7 @@

 You can add custom command keybindings in your config.yml (accessible by pressing 'o' on the status panel from within lazygit) like so:

-```yml
+```
 customCommands:
  - key: '<c-r>'
    command: 'hub browse -- "commit/{{.SelectedLocalCommit.Sha}}"'
@@ -35,20 +35,6 @@ customCommands:
    command: "git flow {{index .PromptResponses 0}} start {{index .PromptResponses 1}}"
    context: 'localBranches'
    loadingText: 'creating branch'
-  - key : 'r'
-    description: 'Checkout a remote branch as FETCH_HEAD'
-    command: "git fetch {{index .PromptResponses 0}} {{index .PromptResponses 1}} && git checkout FETCH_HEAD"
-    context: 'remotes'
-    prompts:
-      - type: 'input'
-        title: 'Remote:'
-        initialValue: "{{index .SelectedRemote.Name }}"
-      - type: 'menuFromCommand'
-        title: 'Remote branch:'
-        command: 'git branch  -r --list {{index .PromptResponses 0}}/*'
-        filter: '.*{{index .PromptResponses 0}}/(?P<branch>.*)'
-        valueFormat: '{{ .branch }}'
-        labelFormat: '{{ .branch | green }}'
 ```

 Looking at the command assigned to the 'n' key, here's what the result looks like:
@@ -93,28 +79,12 @@ The permitted contexts are:

 The permitted prompt fields are:

-| _field_           | _description_                                                                    | _required_ |
-| ------------      | -------------------------------------------------------------------------------- | ---------- |
-| type              | one of 'input' or 'menu'                                                         | yes        |
-| title             | the title to display in the popup panel                                          | no         |
-| initialValue      | (only applicable to 'input' prompts) the initial value to appear in the text box | no         |
-| options           | (only applicable to 'menu' prompts) the options to display in the menu           | no         |
-| command           | (only applicable to 'menuFromCommand' prompts) the command to run to generate    | yes        |
-|                   | menu options                                                                     |            |
-| filter            | (only applicable to 'menuFromCommand' prompts) the regexp to run specifying      | yes        |
-|                   | groups which are going to be kept from the command's output                      |            |
-| valueFormat       | (only applicable to 'menuFromCommand' prompts) how to format matched groups from | yes        |
-|                   | the filter to construct a menu item's value (What gets appended to prompt        |            |
-|                   | responses when the item is selected). You can use named groups,                  |            |
-|                   | or `{{ .group_GROUPID }}`.                                                       |            |
-|                   | PS: named groups keep first match only                                           |            |
-| labelFormat       | (only applicable to 'menuFromCommand' prompts) how to format matched groups from | no         |
-|                   | the filter to construct the item's label (What's shown on screen). You can use   |            |
-|                   | named groups, or `{{ .group_GROUPID }}`. You can also color each match with      |            |
-|                   | `{{ .group_GROUPID | colorname }}` (Color names from                             |            |
-|                   | [here](https://github.com/jesseduffield/lazygit/blob/master/docs/Config.md))     |            |
-|                   | If `labelFormat` is not specified, `valueFormat` is shown instead.               |            |
-|                   | PS: named groups keep first match only                                           |            |
+| _field_      | _description_                                                                    | _required_ |
+| ------------ | -------------------------------------------------------------------------------- | ---------- |
+| type         | one of 'input' or 'menu'                                                         | yes        |
+| title        | the title to display in the popup panel                                          | no         |
+| initialValue | (only applicable to 'input' prompts) the initial value to appear in the text box | no         |
+| options      | (only applicable to 'menu' prompts) the options to display in the menu           | no         |

 The permitted option fields are:
 | _field_ | _description_ | _required_ |
@@ -125,7 +95,7 @@ The permitted option fields are:

 If an option has no name the value will be displayed to the user in place of the name, so you're allowed to only include the value like so:

-```yml
+```
    prompts:
      - type: 'menu'
        title: 'What kind of branch is it?'
@@ -153,7 +123,7 @@ SelectedCommitFile
 CheckedOutBranch
 ```

-To see what fields are available on e.g. the `SelectedFile`, see [here](https://github.com/jesseduffield/lazygit/blob/master/pkg/commands/models/file.go) (all the modelling lives in the same directory). Note that the custom commands feature does not guarantee backwards compatibility (until we hit lazygit version 1.0 of course) which means a field you're accessing on an object may no longer be available from one release to the next. Typically however, all you'll need is `{{.SelectedFile.Name}}`, `{{.SelectedLocalCommit.Sha}}` and `{{.SelectedBranch.Name}}`. In the future we will likely introduce a tighter interface that exposes a limited set of fields for each model.
+To see what fields are available on e.g. the `SelectedFile`, see [here](https://github.com/jesseduffield/lazygit/blob/master/pkg/commands/file.go) (all the modelling lives in the same directory). Note that the custom commands feature does not guarantee backwards compatibility (until we hit lazygit version 1.0 of course) which means a field you're accessing on an object may no longer be available from one release to the next. Typically however, all you'll need is `{{.SelectedFile.Name}}`, `{{.SelectedLocalCommit.Sha}}` and `{{.SelectedBranch.Name}}`. In the future we will likely introduce a tighter interface that exposes a limited set of fields for each model.

 ### Keybinding collisions

@@ -21,7 +21,7 @@ the `colorArg` key is for whether you want the `--color=always` arg in your `git
 git:
  paging:
    colorArg: always
-    pager: delta --dark --paging=never
+    pager: delta --dark --paging=never --24-bit-color=never
 ```

 ![](https://i.imgur.com/QJpQkF3.png)
@@ -1,7 +0,0 @@
-# Documentation Overview 
-
-* [Configuration](./Config.md).
-* [Custom Commands](./Custom_Command_Keybindings.md)
-* [Custom Pagers](./Custom_Pagers.md)
-* [Keybindings](./keybindings)
-* [Undo/Redo](./Undoing.md)
@@ -3,7 +3,6 @@
 ## Global Keybindings

 <pre>
-  <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
@@ -17,22 +16,21 @@
  <kbd>+</kbd>: next screen mode (normal/half/fullscreen)
  <kbd>_</kbd>: prev screen mode
  <kbd>:</kbd>: execute custom command
-  <kbd>ctrl+s</kbd>: view filter-by-path options
+  <kbd>|</kbd>: view scoping options
  <kbd>W</kbd>: open diff menu
  <kbd>ctrl+e</kbd>: open diff menu
-  <kbd>@</kbd>: open command log menu
 </pre>

 ## List Panel Navigation

 <pre>
-  <kbd>.</kbd>: next page
-  <kbd>,</kbd>: previous page
-  <kbd><</kbd>: scroll to top
-  <kbd>></kbd>: scroll to bottom
-  <kbd>/</kbd>: start search
  <kbd>]</kbd>: next tab
  <kbd>[</kbd>: previous tab
+  <kbd>,</kbd>: previous page
+  <kbd>.</kbd>: next page
+  <kbd><</kbd>: scroll to top
+  <kbd>/</kbd>: start search
+  <kbd>></kbd>: scroll to bottom
 </pre>

 ## Branches Panel (Branches Tab)
@@ -40,8 +38,6 @@
 <pre>
  <kbd>space</kbd>: checkout
  <kbd>o</kbd>: create pull request
-  <kbd>O</kbd>: create pull request options
-  <kbd>ctrl+y</kbd>: copy pull request URL to clipboard
  <kbd>c</kbd>: checkout by name
  <kbd>F</kbd>: force checkout
  <kbd>n</kbd>: new branch
@@ -112,8 +108,7 @@
  <kbd>o</kbd>: open file
  <kbd>e</kbd>: edit file
  <kbd>space</kbd>: toggle file included in patch
-  <kbd>enter</kbd>: enter file to add selected lines to the patch (or toggle directory collapsed)
-  <kbd>`</kbd>: toggle file tree view
+  <kbd>enter</kbd>: enter file to add selected lines to the patch
 </pre>

 ## Commits Panel (Commits)
@@ -125,7 +120,7 @@
  <kbd>g</kbd>: reset to this commit
  <kbd>f</kbd>: fixup commit
  <kbd>F</kbd>: create fixup commit for this commit
-  <kbd>S</kbd>: squash all 'fixup!' commits above selected commit (autosquash)
+  <kbd>S</kbd>: squash above commits
  <kbd>d</kbd>: delete commit
  <kbd>ctrl+j</kbd>: move commit down one
  <kbd>ctrl+k</kbd>: move commit up one
@@ -142,7 +137,6 @@
  <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
 </pre>

 ## Commits Panel (Reflog Tab)
@@ -157,12 +151,6 @@
  <kbd>ctrl+o</kbd>: copy commit SHA to clipboard
 </pre>

-## Extras Panel
-
-<pre>
-  <kbd>@</kbd>: open command log menu
-</pre>
-
 ## Files Panel (Files)

 <pre>
@@ -180,13 +168,10 @@
  <kbd>S</kbd>: view stash options
  <kbd>a</kbd>: stage/unstage all
  <kbd>D</kbd>: view reset options
-  <kbd>enter</kbd>: stage individual hunks/lines for file, or collapse/expand for directory
+  <kbd>enter</kbd>: stage individual hunks/lines
  <kbd>f</kbd>: fetch
  <kbd>ctrl+o</kbd>: copy the file name to the clipboard
  <kbd>g</kbd>: view upstream reset options
-  <kbd>`</kbd>: toggle file tree view
-  <kbd>M</kbd>: open external merge tool (git mergetool)
-  <kbd>ctrl+w</kbd>: Toggle whether or not whitespace changes are shown in the diff view
 </pre>

 ## Files Panel (Submodules)
@@ -206,21 +191,20 @@

 <pre>
  <kbd>esc</kbd>: return to files panel
-  <kbd>M</kbd>: open external merge tool (git mergetool)
  <kbd>space</kbd>: pick hunk
-  <kbd>b</kbd>: pick all hunks
+  <kbd>b</kbd>: pick both hunks
  <kbd>◄</kbd>: select previous conflict
  <kbd>►</kbd>: select next conflict
-  <kbd>▲</kbd>: select previous hunk
-  <kbd>▼</kbd>: select next hunk
+  <kbd>▲</kbd>: select top hunk
+  <kbd>▼</kbd>: select bottom hunk
  <kbd>z</kbd>: undo
 </pre>

 ## Main Panel (Normal)

 <pre>
-  <kbd>Ő</kbd>: scroll down (fn+up)
-  <kbd>ő</kbd>: scroll up (fn+down)
+  <kbd>￣</kbd>: scroll down (fn+up)
+  <kbd>￤</kbd>: scroll up (fn+down)
 </pre>

 ## Main Panel (Patch Building)
@@ -283,5 +267,4 @@
  <kbd>o</kbd>: open config file
  <kbd>u</kbd>: check for update
  <kbd>enter</kbd>: switch to a recent repo
-  <kbd>a</kbd>: show all branch logs
 </pre>
@@ -1,11 +1,10 @@
 # Lazygit Sneltoetsen

-## Globale Sneltoetsen
+## Globaale Sneltoetsen

 <pre>
-  <kbd>ctrl+r</kbd>: wissel naar een recente repo (<c-r>)
-  <kbd>pgup</kbd>: scroll naar beneden vanaf hoofdpaneel (fn+up)
-  <kbd>pgdown</kbd>: scroll naar beneden vanaf hoofdpaneel (fn+down)
+  <kbd>pgup</kbd>: scroll naar beneden vanaf hooft paneel (fn+up)
+  <kbd>pgdown</kbd>: scroll naar beneden vabaf hooft paneel (fn+down)
  <kbd>m</kbd>: bekijk merge/rebase opties
  <kbd>ctrl+p</kbd>: bekijk aangepaste patch opties
  <kbd>P</kbd>: push
@@ -14,34 +13,31 @@
  <kbd>x</kbd>: open menu
  <kbd>z</kbd>: ongedaan maken (via reflog) (experimenteel)
  <kbd>ctrl+z</kbd>: redo (via reflog) (experimenteel)
-  <kbd>+</kbd>: volgende scherm modus (normaal/half/groot)
-  <kbd>_</kbd>: vorige scherm modus
-  <kbd>:</kbd>: voor aangepaste commando uit
-  <kbd>ctrl+s</kbd>: bekijk scoping opties
+  <kbd>+</kbd>: volgende schermmode (normaal/half/groot )
+  <kbd>_</kbd>: vorige schermmode
+  <kbd>:</kbd>: voor aangepast commando uit
+  <kbd>|</kbd>: bekijk scoping opties
  <kbd>W</kbd>: open diff menu
  <kbd>ctrl+e</kbd>: open diff menu
-  <kbd>@</kbd>: open command log menu
 </pre>

-## Lijstpaneel Navigatie
+## List Panel Navigation

 <pre>
-  <kbd>.</kbd>: volgende pagina
+  <kbd>]</kbd>: volgende tab
+  <kbd>[</kbd>: vorige tab
  <kbd>,</kbd>: vorige pagina
+  <kbd>.</kbd>: volgende pagina
  <kbd><</kbd>: scroll naar boven
+  <kbd>/</kbd>: start met zoekken
  <kbd>></kbd>: scroll naar beneden
-  <kbd>/</kbd>: start met zoeken
-  <kbd>]</kbd>: volgende tabblad
-  <kbd>[</kbd>: vorige tabblad
 </pre>

-## Branches Paneel (Branches Tabblad)
+## Branches Paneel (Branches Tab)

 <pre>
  <kbd>space</kbd>: uitchecken
-  <kbd>o</kbd>: maak een pull-request
-  <kbd>O</kbd>: bekijk opties voor pull-aanvraag
-  <kbd>ctrl+y</kbd>: kopieer de URL van het pull-verzoek naar het klembord
+  <kbd>o</kbd>: maak een pull-aanvraag
  <kbd>c</kbd>: uitchecken bij naam
  <kbd>F</kbd>: forceer checkout
  <kbd>n</kbd>: nieuwe branch
@@ -52,16 +48,16 @@
  <kbd>f</kbd>: fast-forward deze branch vanaf zijn upstream
  <kbd>g</kbd>: bekijk reset opties
  <kbd>R</kbd>: hernoem branch
-  <kbd>ctrl+o</kbd>: kopieer branch name naar klembord
-  <kbd>enter</kbd>: bekijk commits
+  <kbd>ctrl+o</kbd>: copieer branch name naar clipboard
+  <kbd>enter</kbd>: view commits
 </pre>

-## Branches Paneel (Remote Branches (in Remotes tabblad))
+## Branches Paneel (Remote Branches (in Remotes tab))

 <pre>
  <kbd>esc</kbd>: Ga terug naar remotes lijst
  <kbd>g</kbd>: bekijk reset opties
-  <kbd>enter</kbd>: bekijk commits
+  <kbd>enter</kbd>: view commits
  <kbd>space</kbd>: uitchecken
  <kbd>n</kbd>: nieuwe branch
  <kbd>M</kbd>: merge in met huidige checked out branch
@@ -70,7 +66,7 @@
  <kbd>u</kbd>: stel in als upstream van uitgecheckte branch
 </pre>

-## Branches Paneel (Remotes Tabblad)
+## Branches Paneel (Remotes Tab)

 <pre>
  <kbd>f</kbd>: fetch remote
@@ -86,13 +82,13 @@
  <kbd>space</kbd>: checkout commit
  <kbd>g</kbd>: bekijk reset opties
  <kbd>n</kbd>: nieuwe branch
-  <kbd>c</kbd>: kopieer commit (cherry-pick)
-  <kbd>C</kbd>: kopieer commit reeks (cherry-pick)
-  <kbd>ctrl+r</kbd>: reset cherry-picked (gekopieerde) commits selectie
-  <kbd>ctrl+o</kbd>: kopieer commit SHA naar klembord
+  <kbd>c</kbd>: kopiëer commit (cherry-pick)
+  <kbd>C</kbd>: kopiëer commit reeks (cherry-pick)
+  <kbd>ctrl+r</kbd>: reset cherry-picked (gecopieerde) commits selectie
+  <kbd>ctrl+o</kbd>: copieer commit SHA naar clipboard
 </pre>

-## Branches Paneel (Tags Tabblad)
+## Branches Paneel (Tags Tab)

 <pre>
  <kbd>space</kbd>: uitchecken
@@ -100,7 +96,7 @@
  <kbd>P</kbd>: push tag
  <kbd>n</kbd>: creëer tag
  <kbd>g</kbd>: bekijk reset opties
-  <kbd>enter</kbd>: bekijk commits
+  <kbd>enter</kbd>: view commits
 </pre>

 ## Commit bestanden Paneel
@@ -112,8 +108,7 @@
  <kbd>o</kbd>: open bestand
  <kbd>e</kbd>: verander bestand
  <kbd>space</kbd>: toggle bestand inbegrepen in patch
-  <kbd>enter</kbd>: enter bestand om geselecteerde regels toe te voegen aan de patch
-  <kbd>`</kbd>: toggle bestandsboom weergave
+  <kbd>enter</kbd>: enter bestand to add selecteered lines to the patch
 </pre>

 ## Commits Paneel (Commits)
@@ -133,34 +128,27 @@
  <kbd>A</kbd>: wijzig commit met staged veranderingen
  <kbd>p</kbd>: kies commit (wanneer midden in rebase)
  <kbd>t</kbd>: commit ongedaan maken
-  <kbd>c</kbd>: kopieer commit (cherry-pick)
-  <kbd>ctrl+o</kbd>: kopieer commit SHA naar klembord
-  <kbd>C</kbd>: kopieer commit reeks (cherry-pick)
+  <kbd>c</kbd>: kopiëer commit (cherry-pick)
+  <kbd>ctrl+o</kbd>: copieer commit SHA naar clipboard
+  <kbd>C</kbd>: kopiëer commit reeks (cherry-pick)
  <kbd>v</kbd>: plak commits (cherry-pick)
  <kbd>enter</kbd>: bekijk gecommite bestanden
  <kbd>space</kbd>: checkout commit
-  <kbd>n</kbd>: creëer nieuwe branch van commit
+  <kbd>n</kbd>: create new branch off of commit
  <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>ctrl+r</kbd>: reset cherry-picked (gecopieerde) commits selectie
 </pre>

-## Commits Paneel (Reflog Tabblad)
+## Commits Paneel (Reflog Tab)

 <pre>
  <kbd>enter</kbd>: bekijk gecommite bestanden
  <kbd>space</kbd>: checkout commit
  <kbd>g</kbd>: bekijk reset opties
-  <kbd>c</kbd>: kopieer commit (cherry-pick)
-  <kbd>C</kbd>: kopieer commit reeks (cherry-pick)
-  <kbd>ctrl+r</kbd>: reset cherry-picked (gekopieerde) commits selectie
-  <kbd>ctrl+o</kbd>: kopieer commit SHA naar klembord
-</pre>
-
-## Extras Paneel
-
-<pre>
-  <kbd>@</kbd>: open command log menu
+  <kbd>c</kbd>: kopiëer commit (cherry-pick)
+  <kbd>C</kbd>: kopiëer commit reeks (cherry-pick)
+  <kbd>ctrl+r</kbd>: reset cherry-picked (gecopieerde) commits selectie
+  <kbd>ctrl+o</kbd>: copieer commit SHA naar clipboard
 </pre>

 ## Bestanden Paneel (Bestanden)
@@ -184,29 +172,25 @@
  <kbd>f</kbd>: fetch
  <kbd>ctrl+o</kbd>: kopieer de bestandsnaam naar het klembord
  <kbd>g</kbd>: bekijk upstream reset opties
-  <kbd>`</kbd>: toggle bestandsboom weergave
-  <kbd>M</kbd>: open external merge tool (git mergetool)
-  <kbd>ctrl+w</kbd>: Toggle whether or not whitespace changes are shown in the diff view
 </pre>

 ## Bestanden Paneel (Submodules)

 <pre>
-  <kbd>ctrl+o</kbd>: kopieer submodule naam naar klembord
+  <kbd>ctrl+o</kbd>: copy submodule name to clipboard
  <kbd>enter</kbd>: enter submodule
-  <kbd>d</kbd>: bekijk reset en verwijder submodule opties
+  <kbd>d</kbd>: view reset and remove submodule options
  <kbd>u</kbd>: update submodule
-  <kbd>n</kbd>: voeg nieuwe submodule toe
+  <kbd>n</kbd>: add new submodule
  <kbd>e</kbd>: update submodule URL
-  <kbd>i</kbd>: initialiseer submodule
-  <kbd>b</kbd>: bekijk bulk submodule opties
+  <kbd>i</kbd>: initialize submodule
+  <kbd>b</kbd>: view bulk submodule options
 </pre>

-## Hoofd Paneel (Mergen)
+## Hooft Paneel (Merggen)

 <pre>
  <kbd>esc</kbd>: ga terug naar het bestanden paneel
-  <kbd>M</kbd>: open external merge tool (git mergetool)
  <kbd>space</kbd>: kies hunk
  <kbd>b</kbd>: kies bijde hunks
  <kbd>◄</kbd>: selecteer voorgaand conflict
@@ -216,29 +200,29 @@
  <kbd>z</kbd>: ongedaan maken
 </pre>

-## Hoofd Paneel (Normaal)
+## Hooft Paneel (Normaal)

 <pre>
-  <kbd>Ő</kbd>: scroll omlaag (fn+up)
-  <kbd>ő</kbd>: scroll omhoog (fn+down)
+  <kbd>￣</kbd>: scroll omlaag (fn+up)
+  <kbd>￤</kbd>: scroll omhoog (fn+down)
 </pre>

-## Hoofd Paneel (Patch Bouwen)
+## Hooft Paneel (Patch Bouwen)

 <pre>
-  <kbd>esc</kbd>: sluit lijn-bij-lijn modus
+  <kbd>esc</kbd>: sluit lijn-bij-lijn mode
  <kbd>o</kbd>: open bestand
  <kbd>▲</kbd>: selecteer de vorige lijn
  <kbd>▼</kbd>: selecteer de volgende lijn
  <kbd>◄</kbd>: selecteer de vorige hunk
  <kbd>►</kbd>: selecteer de volgende hunk
  <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>v</kbd>: toggle drag  selecteer
+  <kbd>V</kbd>: toggle drag  selecteer
+  <kbd>a</kbd>: toggle  selecteer hunk
 </pre>

-## Hoofd Paneel (Staging)
+## Hooft Paneel (Staging)

 <pre>
  <kbd>esc</kbd>: ga terug naar het bestanden paneel
@@ -252,9 +236,9 @@
  <kbd>►</kbd>: selecteer de volgende hunk
  <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>v</kbd>: toggle drag  selecteer
+  <kbd>V</kbd>: toggle drag  selecteer
+  <kbd>a</kbd>: toggle  selecteer hunk
  <kbd>c</kbd>: Commit veranderingen
  <kbd>w</kbd>: commit veranderingen zonder pre-commit hook
  <kbd>C</kbd>: commit veranderingen met de git editor
@@ -269,7 +253,7 @@
 ## Stash Paneel

 <pre>
-  <kbd>enter</kbd>: bekijk bestanden van stash entry
+  <kbd>enter</kbd>: view stash entry's files
  <kbd>space</kbd>: toepassen
  <kbd>g</kbd>: pop
  <kbd>d</kbd>: laten vallen
@@ -283,5 +267,4 @@
  <kbd>o</kbd>: open config bestand
  <kbd>u</kbd>: check voor updates
  <kbd>enter</kbd>: wissel naar een recente repo
-  <kbd>a</kbd>: alle logs van de branch laten zien
 </pre>
@@ -3,7 +3,6 @@
 ## Globalne

 <pre>
-  <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
@@ -17,22 +16,21 @@
  <kbd>+</kbd>: next screen mode (normal/half/fullscreen)
  <kbd>_</kbd>: prev screen mode
  <kbd>:</kbd>: execute custom command
-  <kbd>ctrl+s</kbd>: view filter-by-path options
+  <kbd>|</kbd>: view scoping options
  <kbd>W</kbd>: open diff menu
  <kbd>ctrl+e</kbd>: open diff menu
-  <kbd>@</kbd>: open command log menu
 </pre>

 ## List Panel Navigation

 <pre>
-  <kbd>.</kbd>: next page
-  <kbd>,</kbd>: previous page
-  <kbd><</kbd>: scroll to top
-  <kbd>></kbd>: scroll to bottom
-  <kbd>/</kbd>: start search
  <kbd>]</kbd>: next tab
  <kbd>[</kbd>: previous tab
+  <kbd>,</kbd>: previous page
+  <kbd>.</kbd>: next page
+  <kbd><</kbd>: scroll to top
+  <kbd>/</kbd>: start search
+  <kbd>></kbd>: scroll to bottom
 </pre>

 ## Gałęzie Panel (Branches Tab)
@@ -40,8 +38,6 @@
 <pre>
  <kbd>space</kbd>: przełącz
  <kbd>o</kbd>: utwórz żądanie wyciągnięcia
-  <kbd>O</kbd>: utwórz opcje żądania ściągnięcia
-  <kbd>ctrl+y</kbd>: skopiuj adres URL żądania ściągnięcia do schowka
  <kbd>c</kbd>: przełącz używając nazwy
  <kbd>F</kbd>: wymuś przełączenie
  <kbd>n</kbd>: nowa gałąź
@@ -112,8 +108,7 @@
  <kbd>o</kbd>: otwórz plik
  <kbd>e</kbd>: edytuj plik
  <kbd>space</kbd>: toggle file included in patch
-  <kbd>enter</kbd>: enter file to add selected lines to the patch (or toggle directory collapsed)
-  <kbd>`</kbd>: toggle file tree view
+  <kbd>enter</kbd>: enter file to add selected lines to the patch
 </pre>

 ## Commity Panel (Commity)
@@ -125,7 +120,7 @@
  <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>S</kbd>: squash above commits
  <kbd>d</kbd>: delete commit
  <kbd>ctrl+j</kbd>: move commit down one
  <kbd>ctrl+k</kbd>: move commit up one
@@ -142,7 +137,6 @@
  <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
 </pre>

 ## Commity Panel (Reflog Tab)
@@ -157,12 +151,6 @@
  <kbd>ctrl+o</kbd>: copy commit SHA to clipboard
 </pre>

-## Extras Panel
-
-<pre>
-  <kbd>@</kbd>: open command log menu
-</pre>
-
 ## Pliki Panel (Pliki)

 <pre>
@@ -184,9 +172,6 @@
  <kbd>f</kbd>: fetch
  <kbd>ctrl+o</kbd>: copy the file name to the clipboard
  <kbd>g</kbd>: view upstream reset options
-  <kbd>`</kbd>: toggle file tree view
-  <kbd>M</kbd>: open external merge tool (git mergetool)
-  <kbd>ctrl+w</kbd>: Toggle whether or not whitespace changes are shown in the diff view
 </pre>

 ## Pliki Panel (Submodules)
@@ -206,21 +191,20 @@

 <pre>
  <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>b</kbd>: pick both hunks
  <kbd>◄</kbd>: select previous conflict
  <kbd>►</kbd>: select next conflict
-  <kbd>▲</kbd>: select previous hunk
-  <kbd>▼</kbd>: select next hunk
+  <kbd>▲</kbd>: select top hunk
+  <kbd>▼</kbd>: select bottom hunk
  <kbd>z</kbd>: cofnij
 </pre>

 ## Main Panel (Normal)

 <pre>
-  <kbd>Ő</kbd>: scroll down (fn+up)
-  <kbd>ő</kbd>: scroll up (fn+down)
+  <kbd>￣</kbd>: scroll down (fn+up)
+  <kbd>￤</kbd>: scroll up (fn+down)
 </pre>

 ## Main Panel (Patch Building)
@@ -283,5 +267,4 @@
  <kbd>o</kbd>: otwórz plik konfiguracyjny
  <kbd>u</kbd>: sprawdź aktualizacje
  <kbd>enter</kbd>: switch to a recent repo
-  <kbd>a</kbd>: pokazywać wszystkie logi branżowe
 </pre>
@@ -6,42 +6,35 @@ require (
 	github.com/OpenPeeDeeP/xdg v1.0.0
 	github.com/atotto/clipboard v0.1.2
 	github.com/aybabtme/humanlog v0.4.1
-	github.com/cli/safeexec v1.0.0
 	github.com/cloudfoundry/jibber_jabber v0.0.0-20151120183258-bcc4c8345a21
 	github.com/creack/pty v1.1.11
-	github.com/fatih/color v1.9.0 // indirect
+	github.com/fatih/color v1.9.0
 	github.com/fsnotify/fsnotify v1.4.7
-	github.com/go-errors/errors v1.4.1
+	github.com/go-errors/errors v1.1.1
 	github.com/go-logfmt/logfmt v0.5.0 // indirect
 	github.com/golang-collections/collections v0.0.0-20130729185459-604e922904d3
 	github.com/golang/protobuf v1.3.2 // indirect
-	github.com/google/go-cmp v0.5.6 // indirect
-	github.com/gookit/color v1.4.2
+	github.com/google/go-cmp v0.3.1 // indirect
 	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/minimal/gitignore v0.3.3-0.20211018110810-9cde264e6b1e
+	github.com/jesseduffield/gocui v0.3.1-0.20201010224802-8a6768078fd7
+	github.com/jesseduffield/termbox-go v0.0.0-20200823212418-a2289ed6aafe
 	github.com/jesseduffield/yaml v2.1.0+incompatible
 	github.com/kardianos/osext v0.0.0-20190222173326-2bc1f35cddc0
 	github.com/konsorten/go-windows-terminal-sequences v1.0.2 // indirect
-	github.com/kylelemons/godebug v1.1.0 // indirect
-	github.com/kyokomi/emoji/v2 v2.2.8
-	github.com/lucasb-eyer/go-colorful v1.2.0
-	github.com/mattn/go-colorable v0.1.11 // indirect
-	github.com/mattn/go-runewidth v0.0.13
+	github.com/mattn/go-colorable v0.1.7 // indirect
+	github.com/mattn/go-runewidth v0.0.9
 	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/sahilm/fuzzy v0.1.0
 	github.com/sirupsen/logrus v1.4.2
 	github.com/spkg/bom v0.0.0-20160624110644-59b7046e48ad
-	github.com/stretchr/testify v1.7.0
-	github.com/xo/terminfo v0.0.0-20210125001918-ca9a967f8778
+	github.com/stretchr/testify v1.4.0
+	github.com/tcnksm/go-gitconfig v0.1.2
 	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/term v0.0.0-20210927222741-03fcf44c2211 // indirect
-	golang.org/x/text v0.3.7 // indirect
-	gopkg.in/ozeidan/fuzzy-patricia.v3 v3.0.0
+	golang.org/x/sys v0.0.0-20201005172224-997123666555 // indirect
 )
+
+replace github.com/go-git/go-git/v5 => github.com/jesseduffield/go-git/v5 v5.1.1
@@ -11,8 +11,6 @@ github.com/atotto/clipboard v0.1.2/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn
 github.com/aybabtme/humanlog v0.4.1 h1:D8d9um55rrthJsP8IGSHBcti9lTb/XknmDAX6Zy8tek=
 github.com/aybabtme/humanlog v0.4.1/go.mod h1:B0bnQX4FTSU3oftPMTTPvENCy8LqixLDvYJA9TUCAGo=
 github.com/aybabtme/rgbterm v0.0.0-20170906152045-cc83f3b3ce59/go.mod h1:q/89r3U2H7sSsE2t6Kca0lfwTK8JdoNGS/yzM/4iH5I=
-github.com/cli/safeexec v1.0.0 h1:0VngyaIyqACHdcMNWfo6+KdUYnqEr2Sg+bSP1pdF+dI=
-github.com/cli/safeexec v1.0.0/go.mod h1:Z/D4tTN8Vs5gXYHDCbaM1S/anmEDnJb1iW0+EJ5zx3Q=
 github.com/cloudfoundry/jibber_jabber v0.0.0-20151120183258-bcc4c8345a21 h1:tuijfIjZyjZaHq9xDUh0tNitwXshJpbLkqMOJv4H3do=
 github.com/cloudfoundry/jibber_jabber v0.0.0-20151120183258-bcc4c8345a21/go.mod h1:po7NpZ/QiTKzBKyrsEAxwnTamCoh8uDk/egRpQ7siIc=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
@@ -23,6 +21,7 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/emirpasic/gods v1.12.0 h1:QAUIPSaCu4G+POclxeqb3F+WPpdKqFGlw36+yOzGlrg=
 github.com/emirpasic/gods v1.12.0/go.mod h1:YfzfFFoVP/catgzJb4IKIqXjX78Ha8FMSDh3ymbK86o=
+github.com/fatih/color v1.7.1-0.20180516100307-2d684516a886 h1:NAFoy+QgUpERgK3y1xiVh5HcOvSeZHpXTTo5qnvnuK4=
 github.com/fatih/color v1.7.1-0.20180516100307-2d684516a886/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
 github.com/fatih/color v1.9.0 h1:8xPHl4/q1VyqGIPif1F+1V3Y3lSmrq01EabUW3CoW5s=
 github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU=
@@ -30,38 +29,31 @@ github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568 h1:BHsljHzVlRcyQhjr
 github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:xEzjJPgXI435gkrCt3MPfRiAkVrwSbHsst4LCFVfpJc=
 github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
-github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdko=
-github.com/gdamore/encoding v1.0.0/go.mod h1:alR0ol34c49FCSBLjhosxzcPHQbf2trDkoo5dl+VrEg=
-github.com/gdamore/tcell/v2 v2.4.0 h1:W6dxJEmaxYvhICFoTY3WrLLEXsQ11SaFnKGVEXW57KM=
-github.com/gdamore/tcell/v2 v2.4.0/go.mod h1:cTTuF84Dlj/RqmaCIV5p4w8uG1zWdk0SF6oBpwHp4fU=
 github.com/gliderlabs/ssh v0.2.2 h1:6zsha5zo/TWhRhwqCD3+EarCAgZ2yN28ipRnGPnwkI0=
 github.com/gliderlabs/ssh v0.2.2/go.mod h1:U7qILu1NlMHj9FlMhZLlkCdDnU1DBEAqr0aevW3Awn0=
-github.com/go-errors/errors v1.0.2/go.mod h1:psDX2osz5VnTOnFWbDeWwS7yejl+uV3FEWEp4lssFEs=
-github.com/go-errors/errors v1.4.1 h1:IvVlgbzSsaUNudsw5dcXSzF3EWyXTi5XrAdngnuhRyg=
-github.com/go-errors/errors v1.4.1/go.mod h1:sIVyrIiJhuEF+Pj9Ebtd6P/rEYROXFi3BopGUQ5a5Og=
+github.com/go-errors/errors v1.1.1 h1:ljK/pL5ltg3qoN+OtN6yCv9HWSfMwxSx90GJCZQxYNg=
+github.com/go-errors/errors v1.1.1/go.mod h1:psDX2osz5VnTOnFWbDeWwS7yejl+uV3FEWEp4lssFEs=
 github.com/go-git/gcfg v1.5.0 h1:Q5ViNfGF8zFgyJWPqYwA7qGFoMTEiBmdlkcfRmpIMa4=
 github.com/go-git/gcfg v1.5.0/go.mod h1:5m20vg6GwYabIxaOonVkTdrILxQMpEShl1xiMF4ua+E=
 github.com/go-git/go-billy/v5 v5.0.0 h1:7NQHvd9FVid8VL4qVUMm8XifBK+2xCoZ2lSk0agRrHM=
 github.com/go-git/go-billy/v5 v5.0.0/go.mod h1:pmpqyWchKfYfrkb/UVH4otLvyi/5gJlGI4Hb3ZqZ3W0=
 github.com/go-git/go-git-fixtures/v4 v4.0.2-0.20200613231340-f56387b50c12 h1:PbKy9zOy4aAKrJ5pibIRpVO2BXnK1Tlcg+caKI7Ox5M=
 github.com/go-git/go-git-fixtures/v4 v4.0.2-0.20200613231340-f56387b50c12/go.mod h1:m+ICp2rF3jDhFgEZ/8yziagdT1C+ZpZcrJjappBCDSw=
+github.com/go-logfmt/logfmt v0.4.0 h1:MP4Eh7ZCb31lleYCFuwm0oe4/YGak+5l1vA2NOE80nA=
 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
 github.com/go-logfmt/logfmt v0.5.0 h1:TrB8swr/68K7m9CcGut2g3UOihhbcbiMAYiuTXdEih4=
 github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
-github.com/gobwas/glob v0.2.3 h1:A4xDbljILXROh+kObIiy5kIaPYD8e96x1tgBhUI5J+Y=
-github.com/gobwas/glob v0.2.3/go.mod h1:d3Ez4x06l9bZtSvzIay5+Yzi0fmZzPgnTbPcKjJAkT8=
 github.com/golang-collections/collections v0.0.0-20130729185459-604e922904d3 h1:zN2lZNZRflqFyxVaTIU61KNKQ9C0055u9CAfpmqUvo4=
 github.com/golang-collections/collections v0.0.0-20130729185459-604e922904d3/go.mod h1:nPpo7qLxd6XL3hWJG/O60sR8ZKfMCiIoNap5GvD12KU=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.2 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs=
 github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ=
-github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/gookit/color v1.4.2 h1:tXy44JFSFkKnELV6WaMo/lLfu/meqITX3iAV52do7lk=
-github.com/gookit/color v1.4.2/go.mod h1:fqRyamkC1W8uxl+lxCQxOT09l/vYfZ+QeiX3rKQHCoQ=
+github.com/google/go-cmp v0.3.1 h1:Xye71clBPdm5HgqGwUkwhbynsUJZhDbS20FvLhQ2izg=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/imdario/mergo v0.3.9 h1:UauaLniWCFHWd+Jp9oCEkTBj8VO/9DKg3PV3VCNMDIg=
 github.com/imdario/mergo v0.3.9/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA=
 github.com/imdario/mergo v0.3.11 h1:3tnifQM4i+fbajXKBHXWEH+KvNHqojZ778UH75j3bGA=
 github.com/imdario/mergo v0.3.11/go.mod h1:jmQim1M+e3UYxmgPu/WyfjB3N3VflVyUjjjwH0dnCYA=
@@ -71,10 +63,10 @@ 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/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/gocui v0.3.1-0.20201010224802-8a6768078fd7 h1:K3MGrjmpPtIhfXmKh/zsIF0CdmNKOkjpIwcUfAa/J2A=
+github.com/jesseduffield/gocui v0.3.1-0.20201010224802-8a6768078fd7/go.mod h1:2RtZznzYKt8RLRwvFiSkXjU0Ei8WwHdubgnlaYH47dw=
+github.com/jesseduffield/termbox-go v0.0.0-20200823212418-a2289ed6aafe h1:qsVhCf2RFyyKIUe/+gJblbCpXMUki9rZrHuEctg6M/E=
+github.com/jesseduffield/termbox-go v0.0.0-20200823212418-a2289ed6aafe/go.mod h1:anMibpZtqNxjDbxrcDEAwSdaJ37vyUeM1f/M4uekib4=
 github.com/jesseduffield/yaml v2.1.0+incompatible h1:HWQJ1gIv2zHKbDYNp0Jwjlj24K8aqpFHnMCynY1EpmE=
 github.com/jesseduffield/yaml v2.1.0+incompatible/go.mod h1:w0xGhOSIJCGYYW+hnFPTutCy5aACpkcwbmORt5axGqk=
 github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
@@ -87,30 +79,26 @@ github.com/konsorten/go-windows-terminal-sequences v1.0.2 h1:DB17ag19krx9CFsz4o3
 github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515 h1:T+h1c/A9Gawja4Y9mFVWj2vyii2bbUNDw3kt9VxK2EY=
 github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
+github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
-github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
-github.com/kyokomi/emoji/v2 v2.2.8 h1:jcofPxjHWEkJtkIbcLHvZhxKgCPl6C7MyjTrD4KDqUE=
-github.com/kyokomi/emoji/v2 v2.2.8/go.mod h1:JUcn42DTdsXJo1SWanHh4HKDEyPaR5CqkmoirZZP9qE=
-github.com/lucasb-eyer/go-colorful v1.0.3/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
-github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
-github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
 github.com/mattn/go-colorable v0.1.0/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
+github.com/mattn/go-colorable v0.1.4 h1:snbPLB8fVfU9iwbbo30TPtbLRzwWu6aJS6Xh4eaaviA=
 github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
-github.com/mattn/go-colorable v0.1.11 h1:nQ+aFkoE2TMGc0b68U2OKSexC+eq46+XwZzWXHRmPYs=
-github.com/mattn/go-colorable v0.1.11/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
+github.com/mattn/go-colorable v0.1.7 h1:bQGKb3vps/j0E9GfJQ03JyhRuxsvdAanXlT9BTw3mdw=
+github.com/mattn/go-colorable v0.1.7/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
 github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
 github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/mattn/go-isatty v0.0.11 h1:FxPOTFNqGkuDUGi3H/qkUbQO4ZiBa2brKq5r0l8TGeM=
 github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE=
-github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y=
-github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
-github.com/mattn/go-runewidth v0.0.10/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
-github.com/mattn/go-runewidth v0.0.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU=
-github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0=
+github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
 github.com/mgutz/str v1.2.0 h1:4IzWSdIz9qPQWLfKZ0rJcV0jcUDpxvP4JVZ4GXQyvSw=
 github.com/mgutz/str v1.2.0/go.mod h1:w1v0ofgLaJdoD0HpQ3fycxKD1WtxpjSo151pK/31q6w=
 github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
@@ -126,11 +114,6 @@ github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
-github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/sahilm/fuzzy v0.1.0 h1:FzWGaw2Opqyu+794ZQ9SYifWv2EIXpwP4q8dY1kDAwI=
-github.com/sahilm/fuzzy v0.1.0/go.mod h1:VFvziUEIMCrT6A6tw2RFIXPXXmzXbOsSHF0DOI8ZK9Y=
 github.com/sergi/go-diff v1.1.0 h1:we8PVUC3FE2uYfodKH/nBHMSetSfHDR6scGdBi+erh0=
 github.com/sergi/go-diff v1.1.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM=
 github.com/sirupsen/logrus v1.4.2 h1:SPIRibHv4MatM3XXNO2BJeFLZwZ2LvZgfQ5+UNI2im4=
@@ -141,24 +124,23 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 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 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
 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=
+github.com/tcnksm/go-gitconfig v0.1.2 h1:iiDhRitByXAEyjgBqsKi9QU4o2TNtv9kPP3RgPgXBPw=
+github.com/tcnksm/go-gitconfig v0.1.2/go.mod h1:/8EhP4H7oJZdIPyT+/UIsG87kTzrzM4UsLGSItWYCpE=
 github.com/urfave/cli v1.20.1-0.20180226030253-8e01ec4cd3e2/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA=
 github.com/xanzy/ssh-agent v0.2.1 h1:TCbipTQL2JiiCprBWx9frJ2eJlCYT00NmctrHxVAr70=
 github.com/xanzy/ssh-agent v0.2.1/go.mod h1:mLlQY/MoOhWBj+gOGMQkOeiEvkx+8pJSI+0Bx9h2kr4=
-github.com/xo/terminfo v0.0.0-20210125001918-ca9a967f8778 h1:QldyIu/L63oPpyvQmHgvgickp1Yw510KJOqX7H24mg8=
-github.com/xo/terminfo v0.0.0-20210125001918-ca9a967f8778/go.mod h1:2MuV+tbUrU1zIOPMxZ5EncGwgmMJsa+9ucAQZXxsObs=
 golang.org/x/crypto v0.0.0-20190219172222-a4c6cb3142f2/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20200302210943-78000ba7a073 h1:xMPOj6Pz6UipU1wXLkrtqpHbR0AVFnyPEQq/wRWz9lM=
 golang.org/x/crypto v0.0.0-20200302210943-78000ba7a073/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20201002170205-7f63de1d35b0 h1:hb9wdF1z5waM+dSIICn1l0DkLVDT3hqhhQsDNUmHPRE=
 golang.org/x/crypto v0.0.0-20201002170205-7f63de1d35b0/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20200301022130-244492dfa37a h1:GuSPYbZzB5/dcLNCwLQLsg3obCJtX9IJhpXkvY7kzk0=
 golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20201002202402-0a1ea396d57c h1:dk0ukUIHmGHqASjP0iue2261isepFCC6XRCSd1nHgDw=
 golang.org/x/net v0.0.0-20201002202402-0a1ea396d57c/go.mod h1:iQL9McJNjoIa5mjH6nYTCTZXUN6RP+XW3eib7Ya3XcI=
@@ -171,33 +153,24 @@ golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5h
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527 h1:uYVVQ9WP/Ds2ROhcaGPeIdVq0RIXVLwsHlnvJ+cT1So=
 golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-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/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=
+golang.org/x/sys v0.0.0-20201005172224-997123666555 h1:fihtqzYxy4E31W1yUlyRGveTZT1JIP0bmKaDZ2ceKAw=
+golang.org/x/sys v0.0.0-20201005172224-997123666555/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
-golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk=
-golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU=
 gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
-gopkg.in/ozeidan/fuzzy-patricia.v3 v3.0.0 h1:KzcWKJ0nMAmGoBhYVMnkWc1rXjB42lKy5aIys4TdLOA=
-gopkg.in/ozeidan/fuzzy-patricia.v3 v3.0.0/go.mod h1:XoytMOotjRRJVkIsQdxsPIioRLYFISEaY9a4tftOXAo=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
 gopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME=
@@ -206,5 +179,3 @@ gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
 gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
@@ -12,7 +12,6 @@ import (
 	"github.com/integrii/flaggy"
 	"github.com/jesseduffield/lazygit/pkg/app"
 	"github.com/jesseduffield/lazygit/pkg/config"
-	"github.com/jesseduffield/lazygit/pkg/constants"
 	"github.com/jesseduffield/lazygit/pkg/env"
 	yaml "github.com/jesseduffield/yaml"
 )
@@ -61,9 +60,6 @@ func main() {
 	gitDir := ""
 	flaggy.String(&gitDir, "g", "git-dir", "equivalent of the --git-dir git argument")

-	customConfig := ""
-	flaggy.String(&customConfig, "ucf", "use-config-file", "Comma seperated list to custom config file(s)")
-
 	flaggy.Parse()

 	if repoPath != "" {
@@ -75,10 +71,6 @@ func main() {
 		gitDir = filepath.Join(repoPath, ".git")
 	}

-	if customConfig != "" {
-		os.Setenv("LG_CONFIG_FILE", customConfig)
-	}
-
 	if useConfigDir != "" {
 		os.Setenv("CONFIG_DIR", useConfigDir)
 	}
@@ -142,6 +134,6 @@ func main() {
 		stackTrace := newErr.ErrorStack()
 		app.Log.Error(stackTrace)

-		log.Fatal(fmt.Sprintf("%s: %s\n\n%s", app.Tr.ErrorOccurred, constants.Links.Issues, stackTrace))
+		log.Fatal(fmt.Sprintf("%s\n\n%s", app.Tr.ErrorOccurred, stackTrace))
 	}
 }
@@ -8,6 +8,7 @@ import (
 	"io/ioutil"
 	"log"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"regexp"
 	"strconv"
@@ -15,7 +16,6 @@ import (

 	"github.com/aybabtme/humanlog"
 	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/commands/git_config"
 	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
 	"github.com/jesseduffield/lazygit/pkg/config"
 	"github.com/jesseduffield/lazygit/pkg/env"
@@ -97,17 +97,13 @@ func newLogger(config config.AppConfigurer) *logrus.Entry {

 // NewApp bootstrap a new application
 func NewApp(config config.AppConfigurer, filterPath string) (*App, error) {
-
 	app := &App{
 		closers: []io.Closer{},
 		Config:  config,
 	}
 	var err error
 	app.Log = newLogger(config)
-	app.Tr, err = i18n.NewTranslationSetFromConfig(app.Log, config.GetUserConfig().Gui.Language)
-	if err != nil {
-		return app, err
-	}
+	app.Tr = i18n.NewTranslationSet(app.Log)

 	// if we are being called in 'demon' mode, we can just return here
 	app.ClientContext = os.Getenv("LAZYGIT_CLIENT_COMMAND")
@@ -127,13 +123,7 @@ func NewApp(config config.AppConfigurer, filterPath string) (*App, error) {
 		return app, err
 	}

-	app.GitCommand, err = commands.NewGitCommand(
-		app.Log,
-		app.OSCommand,
-		app.Tr,
-		app.Config,
-		git_config.NewStdCachedGitConfig(app.Log),
-	)
+	app.GitCommand, err = commands.NewGitCommand(app.Log, app.OSCommand, app.Tr, app.Config)
 	if err != nil {
 		return app, err
 	}
@@ -192,7 +182,7 @@ func (app *App) setupRepo() (bool, error) {
 	}

 	// if we are not in a git repo, we ask if we want to `git init`
-	if err := commands.VerifyInGitRepo(app.OSCommand); err != nil {
+	if err := app.OSCommand.RunCommand("git status"); err != nil {
 		cwd, err := os.Getwd()
 		if err != nil {
 			return false, err
@@ -202,20 +192,10 @@ func (app *App) setupRepo() (bool, error) {
 			return false, err // Current directory appears to be a git repository.
 		}

-		shouldInitRepo := true
-		notARepository := app.Config.GetUserConfig().NotARepository
-		if notARepository == "prompt" {
-			// Offer to initialize a new repository in current directory.
-			fmt.Print(app.Tr.CreateRepo)
-			response, _ := bufio.NewReader(os.Stdin).ReadString('\n')
-			if strings.Trim(response, " \n") != "y" {
-				shouldInitRepo = false
-			}
-		} else if notARepository == "skip" {
-			shouldInitRepo = false
-		}
-
-		if !shouldInitRepo {
+		// Offer to initialize a new repository in current directory.
+		fmt.Print(app.Tr.CreateRepo)
+		response, _ := bufio.NewReader(os.Stdin).ReadString('\n')
+		if strings.Trim(response, " \n") != "y" {
 			// check if we have a recent repo we can open
 			recentRepos := app.Config.GetAppState().RecentRepos
 			if len(recentRepos) > 0 {
@@ -235,7 +215,6 @@ func (app *App) setupRepo() (bool, error) {
 			return false, err
 		}
 	}
-
 	return false, nil
 }

@@ -248,7 +227,7 @@ func (app *App) Run() error {
 		os.Exit(0)
 	}

-	err := app.Gui.RunAndHandleError()
+	err := app.Gui.RunWithSubprocesses()
 	return err
 }

@@ -327,9 +306,6 @@ func TailLogs() {

 	fmt.Printf("Tailing log file %s\n\n", logFilePath)

-	opts := humanlog.DefaultOptions
-	opts.Truncates = false
-
 	_, err = os.Stat(logFilePath)
 	if err != nil {
 		if os.IsNotExist(err) {
@@ -338,5 +314,22 @@ func TailLogs() {
 		log.Fatal(err)
 	}

-	TailLogsForPlatform(logFilePath, opts)
+	cmd := exec.Command("tail", "-f", logFilePath)
+
+	stdout, _ := cmd.StdoutPipe()
+	if err := cmd.Start(); err != nil {
+		log.Fatal(err)
+	}
+
+	opts := humanlog.DefaultOptions
+	opts.Truncates = false
+	if err := humanlog.Scanner(stdout, os.Stdout, opts); err != nil {
+		log.Fatal(err)
+	}
+
+	if err := cmd.Wait(); err != nil {
+		log.Fatal(err)
+	}
+
+	os.Exit(0)
 }
@@ -1,30 +0,0 @@
-//go:build !windows
-// +build !windows
-
-package app
-
-import (
-	"github.com/aybabtme/humanlog"
-	"github.com/jesseduffield/lazygit/pkg/secureexec"
-	"log"
-	"os"
-)
-
-func TailLogsForPlatform(logFilePath string, opts *humanlog.HandlerOptions) {
-	cmd := secureexec.Command("tail", "-f", logFilePath)
-
-	stdout, _ := cmd.StdoutPipe()
-	if err := cmd.Start(); err != nil {
-		log.Fatal(err)
-	}
-
-	if err := humanlog.Scanner(stdout, os.Stdout, opts); err != nil {
-		log.Fatal(err)
-	}
-
-	if err := cmd.Wait(); err != nil {
-		log.Fatal(err)
-	}
-
-	os.Exit(0)
-}
@@ -1,72 +0,0 @@
-//go:build windows
-// +build windows
-
-package app
-
-import (
-	"bufio"
-	"github.com/aybabtme/humanlog"
-	"log"
-	"os"
-	"strings"
-	"time"
-)
-
-func TailLogsForPlatform(logFilePath string, opts *humanlog.HandlerOptions) {
-	var lastModified int64 = 0
-	var lastOffset int64 = 0
-	for {
-		stat, err := os.Stat(logFilePath)
-		if err != nil {
-			log.Fatal(err)
-		}
-		if stat.ModTime().Unix() > lastModified {
-			err = TailFrom(lastOffset, logFilePath, opts)
-			if err != nil {
-				log.Fatal(err)
-			}
-		}
-		lastOffset = stat.Size()
-		time.Sleep(1 * time.Second)
-	}
-}
-
-func OpenAndSeek(filepath string, offset int64) (*os.File, error) {
-	file, err := os.Open(filepath)
-	if err != nil {
-		return nil, err
-	}
-
-	_, err = file.Seek(offset, 0)
-	if err != nil {
-		_ = file.Close()
-		return nil, err
-	}
-	return file, nil
-}
-
-func TailFrom(lastOffset int64, logFilePath string, opts *humanlog.HandlerOptions) error {
-	file, err := OpenAndSeek(logFilePath, lastOffset)
-	if err != nil {
-		return err
-	}
-
-	fileScanner := bufio.NewScanner(file)
-	var lines []string
-	for fileScanner.Scan() {
-		lines = append(lines, fileScanner.Text())
-	}
-	file.Close()
-	lineCount := len(lines)
-	lastTen := lines
-	if lineCount > 10 {
-		lastTen = lines[lineCount-10:]
-	}
-	for _, line := range lastTen {
-		reader := strings.NewReader(line)
-		if err := humanlog.Scanner(reader, os.Stdout, opts); err != nil {
-			log.Fatal(err)
-		}
-	}
-	return nil
-}
@@ -11,19 +11,19 @@ import (

 // NewBranch create new branch
 func (c *GitCommand) NewBranch(name string, base string) error {
-	return c.RunCommand("git checkout -b %s %s", c.OSCommand.Quote(name), c.OSCommand.Quote(base))
+	return c.OSCommand.RunCommand("git checkout -b %s %s", name, base)
 }

 // 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.RunCommandWithOutput("git symbolic-ref --short HEAD")
+	branchName, err := c.OSCommand.RunCommandWithOutput("git symbolic-ref --short HEAD")
 	if err == nil && branchName != "HEAD\n" {
 		trimmedBranchName := strings.TrimSpace(branchName)
 		return trimmedBranchName, trimmedBranchName, nil
 	}
-	output, err := c.RunCommandWithOutput("git branch --contains")
+	output, err := c.OSCommand.RunCommandWithOutput("git branch --contains")
 	if err != nil {
 		return "", "", err
 	}
@@ -47,7 +47,7 @@ func (c *GitCommand) DeleteBranch(branch string, force bool) error {
 		command = "git branch -D"
 	}

-	return c.OSCommand.RunCommand("%s %s", command, c.OSCommand.Quote(branch))
+	return c.OSCommand.RunCommand("%s %s", command, branch)
 }

 // Checkout checks out a branch (or commit), with --force if you set the force arg to true
@@ -59,9 +59,9 @@ type CheckoutOptions struct {
 func (c *GitCommand) Checkout(branch string, options CheckoutOptions) error {
 	forceArg := ""
 	if options.Force {
-		forceArg = " --force"
+		forceArg = "--force "
 	}
-	return c.OSCommand.RunCommandWithOptions(fmt.Sprintf("git checkout%s %s", forceArg, c.OSCommand.Quote(branch)), oscommands.RunCommandOptions{EnvVars: options.EnvVars})
+	return c.OSCommand.RunCommandWithOptions(fmt.Sprintf("git checkout %s %s", forceArg, branch), oscommands.RunCommandOptions{EnvVars: options.EnvVars})
 }

 // GetBranchGraph gets the color-formatted graph of the log for the given branch
@@ -73,24 +73,24 @@ func (c *GitCommand) GetBranchGraph(branchName string) (string, error) {
 }

 func (c *GitCommand) GetUpstreamForBranch(branchName string) (string, error) {
-	output, err := c.RunCommandWithOutput("git rev-parse --abbrev-ref --symbolic-full-name %s@{u}", c.OSCommand.Quote(branchName))
+	output, err := c.OSCommand.RunCommandWithOutput("git rev-parse --abbrev-ref --symbolic-full-name %s@{u}", branchName)
 	return strings.TrimSpace(output), err
 }

 func (c *GitCommand) GetBranchGraphCmdStr(branchName string) string {
 	branchLogCmdTemplate := c.Config.GetUserConfig().Git.BranchLogCmd
 	templateValues := map[string]string{
-		"branchName": c.OSCommand.Quote(branchName),
+		"branchName": branchName,
 	}
 	return utils.ResolvePlaceholderString(branchLogCmdTemplate, templateValues)
 }

 func (c *GitCommand) SetUpstreamBranch(upstream string) error {
-	return c.RunCommand("git branch -u %s", c.OSCommand.Quote(upstream))
+	return c.OSCommand.RunCommand("git branch -u %s", upstream)
 }

 func (c *GitCommand) SetBranchUpstream(remoteName string, remoteBranchName string, branchName string) error {
-	return c.RunCommand("git branch --set-upstream-to=%s/%s %s", c.OSCommand.Quote(remoteName), c.OSCommand.Quote(remoteBranchName), c.OSCommand.Quote(branchName))
+	return c.OSCommand.RunCommand("git branch --set-upstream-to=%s/%s %s", remoteName, remoteBranchName, branchName)
 }

 func (c *GitCommand) GetCurrentBranchUpstreamDifferenceCount() (string, string) {
@@ -124,7 +124,7 @@ type MergeOpts struct {
 func (c *GitCommand) Merge(branchName string, opts MergeOpts) error {
 	mergeArgs := c.Config.GetUserConfig().Git.Merging.Args

-	command := fmt.Sprintf("git merge --no-edit %s %s", mergeArgs, c.OSCommand.Quote(branchName))
+	command := fmt.Sprintf("git merge --no-edit %s %s", mergeArgs, branchName)
 	if opts.FastForwardOnly {
 		command = fmt.Sprintf("%s --ff-only", command)
 	}
@@ -134,28 +134,24 @@ func (c *GitCommand) Merge(branchName string, opts MergeOpts) error {

 // AbortMerge abort merge
 func (c *GitCommand) AbortMerge() error {
-	return c.RunCommand("git merge --abort")
+	return c.OSCommand.RunCommand("git merge --abort")
 }

 func (c *GitCommand) IsHeadDetached() bool {
-	err := c.RunCommand("git symbolic-ref -q HEAD")
+	err := c.OSCommand.RunCommand("git symbolic-ref -q HEAD")
 	return err != nil
 }

 // ResetHardHead runs `git reset --hard`
 func (c *GitCommand) ResetHard(ref string) error {
-	return c.RunCommand("git reset --hard " + c.OSCommand.Quote(ref))
+	return c.OSCommand.RunCommand("git reset --hard " + ref)
 }

 // ResetSoft runs `git reset --soft HEAD`
 func (c *GitCommand) ResetSoft(ref string) error {
-	return c.RunCommand("git reset --soft " + c.OSCommand.Quote(ref))
-}
-
-func (c *GitCommand) ResetMixed(ref string) error {
-	return c.RunCommand("git reset --mixed " + c.OSCommand.Quote(ref))
+	return c.OSCommand.RunCommand("git reset --soft " + ref)
 }

 func (c *GitCommand) RenameBranch(oldName string, newName string) error {
-	return c.RunCommand("git branch --move %s %s", c.OSCommand.Quote(oldName), c.OSCommand.Quote(newName))
+	return c.OSCommand.RunCommand("git branch --move %s %s", oldName, newName)
 }
@@ -1,338 +0,0 @@
-package commands
-
-import (
-	"os/exec"
-	"testing"
-
-	"github.com/jesseduffield/lazygit/pkg/secureexec"
-	"github.com/jesseduffield/lazygit/pkg/test"
-	"github.com/stretchr/testify/assert"
-)
-
-// TestGitCommandGetCommitDifferences is a function.
-func TestGitCommandGetCommitDifferences(t *testing.T) {
-	type scenario struct {
-		testName string
-		command  func(string, ...string) *exec.Cmd
-		test     func(string, string)
-	}
-
-	scenarios := []scenario{
-		{
-			"Can't retrieve pushable count",
-			func(string, ...string) *exec.Cmd {
-				return secureexec.Command("test")
-			},
-			func(pushableCount string, pullableCount string) {
-				assert.EqualValues(t, "?", pushableCount)
-				assert.EqualValues(t, "?", pullableCount)
-			},
-		},
-		{
-			"Can't retrieve pullable count",
-			func(cmd string, args ...string) *exec.Cmd {
-				if args[1] == "HEAD..@{u}" {
-					return secureexec.Command("test")
-				}
-
-				return secureexec.Command("echo")
-			},
-			func(pushableCount string, pullableCount string) {
-				assert.EqualValues(t, "?", pushableCount)
-				assert.EqualValues(t, "?", pullableCount)
-			},
-		},
-		{
-			"Retrieve pullable and pushable count",
-			func(cmd string, args ...string) *exec.Cmd {
-				if args[1] == "HEAD..@{u}" {
-					return secureexec.Command("echo", "10")
-				}
-
-				return secureexec.Command("echo", "11")
-			},
-			func(pushableCount string, pullableCount string) {
-				assert.EqualValues(t, "11", pushableCount)
-				assert.EqualValues(t, "10", pullableCount)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommand()
-			gitCmd.OSCommand.Command = s.command
-			s.test(gitCmd.GetCommitDifferences("HEAD", "@{u}"))
-		})
-	}
-}
-
-// TestGitCommandNewBranch is a function.
-func TestGitCommandNewBranch(t *testing.T) {
-	gitCmd := NewDummyGitCommand()
-	gitCmd.OSCommand.Command = func(cmd string, args ...string) *exec.Cmd {
-		assert.EqualValues(t, "git", cmd)
-		assert.EqualValues(t, []string{"checkout", "-b", "test", "master"}, args)
-
-		return secureexec.Command("echo")
-	}
-
-	assert.NoError(t, gitCmd.NewBranch("test", "master"))
-}
-
-// TestGitCommandDeleteBranch is a function.
-func TestGitCommandDeleteBranch(t *testing.T) {
-	type scenario struct {
-		testName string
-		branch   string
-		force    bool
-		command  func(string, ...string) *exec.Cmd
-		test     func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			"Delete a branch",
-			"test",
-			false,
-			func(cmd string, args ...string) *exec.Cmd {
-				assert.EqualValues(t, "git", cmd)
-				assert.EqualValues(t, []string{"branch", "-d", "test"}, args)
-
-				return secureexec.Command("echo")
-			},
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			"Force delete a branch",
-			"test",
-			true,
-			func(cmd string, args ...string) *exec.Cmd {
-				assert.EqualValues(t, "git", cmd)
-				assert.EqualValues(t, []string{"branch", "-D", "test"}, args)
-
-				return secureexec.Command("echo")
-			},
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommand()
-			gitCmd.OSCommand.Command = s.command
-			s.test(gitCmd.DeleteBranch(s.branch, s.force))
-		})
-	}
-}
-
-// TestGitCommandMerge is a function.
-func TestGitCommandMerge(t *testing.T) {
-	gitCmd := NewDummyGitCommand()
-	gitCmd.OSCommand.Command = func(cmd string, args ...string) *exec.Cmd {
-		assert.EqualValues(t, "git", cmd)
-		assert.EqualValues(t, []string{"merge", "--no-edit", "test"}, args)
-
-		return secureexec.Command("echo")
-	}
-
-	assert.NoError(t, gitCmd.Merge("test", MergeOpts{}))
-}
-
-// TestGitCommandCheckout is a function.
-func TestGitCommandCheckout(t *testing.T) {
-	type scenario struct {
-		testName string
-		command  func(string, ...string) *exec.Cmd
-		test     func(error)
-		force    bool
-	}
-
-	scenarios := []scenario{
-		{
-			"Checkout",
-			func(cmd string, args ...string) *exec.Cmd {
-				assert.EqualValues(t, "git", cmd)
-				assert.EqualValues(t, []string{"checkout", "test"}, args)
-
-				return secureexec.Command("echo")
-			},
-			func(err error) {
-				assert.NoError(t, err)
-			},
-			false,
-		},
-		{
-			"Checkout forced",
-			func(cmd string, args ...string) *exec.Cmd {
-				assert.EqualValues(t, "git", cmd)
-				assert.EqualValues(t, []string{"checkout", "--force", "test"}, args)
-
-				return secureexec.Command("echo")
-			},
-			func(err error) {
-				assert.NoError(t, err)
-			},
-			true,
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommand()
-			gitCmd.OSCommand.Command = s.command
-			s.test(gitCmd.Checkout("test", CheckoutOptions{Force: s.force}))
-		})
-	}
-}
-
-// TestGitCommandGetBranchGraph is a function.
-func TestGitCommandGetBranchGraph(t *testing.T) {
-	gitCmd := NewDummyGitCommand()
-	gitCmd.OSCommand.Command = func(cmd string, args ...string) *exec.Cmd {
-		assert.EqualValues(t, "git", cmd)
-		assert.EqualValues(t, []string{"log", "--graph", "--color=always", "--abbrev-commit", "--decorate", "--date=relative", "--pretty=medium", "test", "--"}, args)
-		return secureexec.Command("echo")
-	}
-	_, err := gitCmd.GetBranchGraph("test")
-	assert.NoError(t, err)
-}
-
-func TestGitCommandGetAllBranchGraph(t *testing.T) {
-	gitCmd := NewDummyGitCommand()
-	gitCmd.OSCommand.Command = func(cmd string, args ...string) *exec.Cmd {
-		assert.EqualValues(t, "git", cmd)
-		assert.EqualValues(t, []string{"log", "--graph", "--all", "--color=always", "--abbrev-commit", "--decorate", "--date=relative", "--pretty=medium"}, args)
-		return secureexec.Command("echo")
-	}
-	cmdStr := gitCmd.Config.GetUserConfig().Git.AllBranchesLogCmd
-	_, err := gitCmd.OSCommand.RunCommandWithOutput(cmdStr)
-	assert.NoError(t, err)
-}
-
-// TestGitCommandCurrentBranchName is a function.
-func TestGitCommandCurrentBranchName(t *testing.T) {
-	type scenario struct {
-		testName string
-		command  func(string, ...string) *exec.Cmd
-		test     func(string, string, error)
-	}
-
-	scenarios := []scenario{
-		{
-			"says we are on the master branch if we are",
-			func(cmd string, args ...string) *exec.Cmd {
-				assert.Equal(t, "git", cmd)
-				return secureexec.Command("echo", "master")
-			},
-			func(name string, displayname string, err error) {
-				assert.NoError(t, err)
-				assert.EqualValues(t, "master", name)
-				assert.EqualValues(t, "master", displayname)
-			},
-		},
-		{
-			"falls back to git `git branch --contains` if symbolic-ref fails",
-			func(cmd string, args ...string) *exec.Cmd {
-				assert.EqualValues(t, "git", cmd)
-
-				switch args[0] {
-				case "symbolic-ref":
-					assert.EqualValues(t, []string{"symbolic-ref", "--short", "HEAD"}, args)
-					return secureexec.Command("test")
-				case "branch":
-					assert.EqualValues(t, []string{"branch", "--contains"}, args)
-					return secureexec.Command("echo", "* master")
-				}
-
-				return nil
-			},
-			func(name string, displayname string, err error) {
-				assert.NoError(t, err)
-				assert.EqualValues(t, "master", name)
-				assert.EqualValues(t, "master", displayname)
-			},
-		},
-		{
-			"handles a detached head",
-			func(cmd string, args ...string) *exec.Cmd {
-				assert.EqualValues(t, "git", cmd)
-
-				switch args[0] {
-				case "symbolic-ref":
-					assert.EqualValues(t, []string{"symbolic-ref", "--short", "HEAD"}, args)
-					return secureexec.Command("test")
-				case "branch":
-					assert.EqualValues(t, []string{"branch", "--contains"}, args)
-					return secureexec.Command("echo", "* (HEAD detached at 123abcd)")
-				}
-
-				return nil
-			},
-			func(name string, displayname string, err error) {
-				assert.NoError(t, err)
-				assert.EqualValues(t, "123abcd", name)
-				assert.EqualValues(t, "(HEAD detached at 123abcd)", displayname)
-			},
-		},
-		{
-			"bubbles up error if there is one",
-			func(cmd string, args ...string) *exec.Cmd {
-				assert.Equal(t, "git", cmd)
-				return secureexec.Command("test")
-			},
-			func(name string, displayname string, err error) {
-				assert.Error(t, err)
-				assert.EqualValues(t, "", name)
-				assert.EqualValues(t, "", displayname)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommand()
-			gitCmd.OSCommand.Command = s.command
-			s.test(gitCmd.CurrentBranchName())
-		})
-	}
-}
-
-// TestGitCommandResetHard is a function.
-func TestGitCommandResetHard(t *testing.T) {
-	type scenario struct {
-		testName string
-		ref      string
-		command  func(string, ...string) *exec.Cmd
-		test     func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			"valid case",
-			"HEAD",
-			test.CreateMockCommand(t, []*test.CommandSwapper{
-				{
-					Expect:  `git reset --hard HEAD`,
-					Replace: "echo",
-				},
-			}),
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-	}
-
-	gitCmd := NewDummyGitCommand()
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd.OSCommand.Command = s.command
-			s.test(gitCmd.ResetHard(s.ref))
-		})
-	}
-}
@@ -2,6 +2,8 @@ package commands

 import (
 	"fmt"
+	"os/exec"
+	"strconv"
 	"strings"

 	"github.com/jesseduffield/lazygit/pkg/commands/models"
@@ -10,7 +12,7 @@ import (

 // RenameCommit renames the topmost commit with the given name
 func (c *GitCommand) RenameCommit(name string) error {
-	return c.RunCommand("git commit --allow-empty --amend --only -m %s", c.OSCommand.Quote(name))
+	return c.OSCommand.RunCommand("git commit --allow-empty --amend -m %s", c.OSCommand.Quote(name))
 }

 // ResetToCommit reset to commit
@@ -18,19 +20,20 @@ func (c *GitCommand) ResetToCommit(sha string, strength string, options oscomman
 	return c.OSCommand.RunCommandWithOptions(fmt.Sprintf("git reset --%s %s", strength, sha), options)
 }

-func (c *GitCommand) CommitCmdStr(message string, flags string) string {
+// Commit commits to git
+func (c *GitCommand) Commit(message string, flags string) (*exec.Cmd, error) {
 	splitMessage := strings.Split(message, "\n")
 	lineArgs := ""
 	for _, line := range splitMessage {
-		lineArgs += fmt.Sprintf(" -m %s", c.OSCommand.Quote(line))
+		lineArgs += fmt.Sprintf(" -m %s", strconv.Quote(line))
 	}

-	flagsStr := ""
-	if flags != "" {
-		flagsStr = fmt.Sprintf(" %s", flags)
+	command := fmt.Sprintf("git commit %s%s", flags, lineArgs)
+	if c.usingGpg() {
+		return c.OSCommand.ShellCommandFromString(command), nil
 	}

-	return fmt.Sprintf("git commit%s%s", flagsStr, lineArgs)
+	return nil, c.OSCommand.RunCommand(command)
 }

 // Get the subject of the HEAD commit
@@ -47,17 +50,19 @@ func (c *GitCommand) GetCommitMessage(commitSha string) (string, error) {
 	return strings.TrimSpace(message), err
 }

-func (c *GitCommand) GetCommitMessageFirstLine(sha string) (string, error) {
-	return c.RunCommandWithOutput("git show --no-patch --pretty=format:%%s %s", sha)
-}
-
 // AmendHead amends HEAD with whatever is staged in your working tree
-func (c *GitCommand) AmendHead() error {
-	return c.OSCommand.RunCommand(c.AmendHeadCmdStr())
+func (c *GitCommand) AmendHead() (*exec.Cmd, error) {
+	command := "git commit --amend --no-edit --allow-empty"
+	if c.usingGpg() {
+		return c.OSCommand.ShellCommandFromString(command), nil
+	}
+
+	return nil, c.OSCommand.RunCommand(command)
 }

-func (c *GitCommand) AmendHeadCmdStr() string {
-	return "git commit --amend --no-edit --allow-empty"
+// PrepareCommitAmendSubProcess prepares a subprocess for `git commit --amend --allow-empty`
+func (c *GitCommand) PrepareCommitAmendSubProcess() *exec.Cmd {
+	return c.OSCommand.PrepareSubProcess("git", "commit", "--amend", "--allow-empty")
 }

 func (c *GitCommand) ShowCmdStr(sha string, filterPath string) string {
@@ -70,11 +75,7 @@ func (c *GitCommand) ShowCmdStr(sha string, filterPath string) string {

 // Revert reverts the selected commit by sha
 func (c *GitCommand) Revert(sha string) error {
-	return c.RunCommand("git revert %s", sha)
-}
-
-func (c *GitCommand) RevertMerge(sha string, parentNumber int) error {
-	return c.RunCommand("git revert %s -m %d", sha, parentNumber)
+	return c.OSCommand.RunCommand("git revert %s", sha)
 }

 // CherryPickCommits begins an interactive rebase with the given shas being cherry picked onto HEAD
@@ -94,5 +95,5 @@ func (c *GitCommand) CherryPickCommits(commits []*models.Commit) error {

 // CreateFixupCommit creates a commit that fixes up a previous commit
 func (c *GitCommand) CreateFixupCommit(sha string) error {
-	return c.RunCommand("git commit --fixup=%s", sha)
+	return c.OSCommand.RunCommand("git commit --fixup=%s", sha)
 }
@@ -1,112 +0,0 @@
-package commands
-
-import (
-	"os/exec"
-	"testing"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/jesseduffield/lazygit/pkg/secureexec"
-	"github.com/jesseduffield/lazygit/pkg/test"
-	"github.com/stretchr/testify/assert"
-)
-
-// TestGitCommandRenameCommit is a function.
-func TestGitCommandRenameCommit(t *testing.T) {
-	gitCmd := NewDummyGitCommand()
-	gitCmd.OSCommand.Command = func(cmd string, args ...string) *exec.Cmd {
-		assert.EqualValues(t, "git", cmd)
-		assert.EqualValues(t, []string{"commit", "--allow-empty", "--amend", "--only", "-m", "test"}, args)
-
-		return secureexec.Command("echo")
-	}
-
-	assert.NoError(t, gitCmd.RenameCommit("test"))
-}
-
-// TestGitCommandResetToCommit is a function.
-func TestGitCommandResetToCommit(t *testing.T) {
-	gitCmd := NewDummyGitCommand()
-	gitCmd.OSCommand.Command = func(cmd string, args ...string) *exec.Cmd {
-		assert.EqualValues(t, "git", cmd)
-		assert.EqualValues(t, []string{"reset", "--hard", "78976bc"}, args)
-
-		return secureexec.Command("echo")
-	}
-
-	assert.NoError(t, gitCmd.ResetToCommit("78976bc", "hard", oscommands.RunCommandOptions{}))
-}
-
-// TestGitCommandCommitStr is a function.
-func TestGitCommandCommitStr(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.CommitCmdStr(s.message, s.flags)
-			assert.Equal(t, s.expected, cmdStr)
-		})
-	}
-}
-
-// TestGitCommandCreateFixupCommit is a function.
-func TestGitCommandCreateFixupCommit(t *testing.T) {
-	type scenario struct {
-		testName string
-		sha      string
-		command  func(string, ...string) *exec.Cmd
-		test     func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			"valid case",
-			"12345",
-			test.CreateMockCommand(t, []*test.CommandSwapper{
-				{
-					Expect:  `git commit --fixup=12345`,
-					Replace: "echo",
-				},
-			}),
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-	}
-
-	gitCmd := NewDummyGitCommand()
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd.OSCommand.Command = s.command
-			s.test(gitCmd.CreateFixupCommit(s.sha))
-		})
-	}
-}
@@ -15,8 +15,12 @@ func (c *GitCommand) ConfiguredPager() string {
 	if os.Getenv("PAGER") != "" {
 		return os.Getenv("PAGER")
 	}
-	output := c.GitConfig.Get("core.pager")
-	return strings.Split(output, "\n")[0]
+	output, err := c.OSCommand.RunCommandWithOutput("git config --get-all core.pager")
+	if err != nil {
+		return ""
+	}
+	trimmedOutput := strings.TrimSpace(output)
+	return strings.Split(trimmedOutput, "\n")[0]
 }

 func (c *GitCommand) GetPager(width int) string {
@@ -38,13 +42,11 @@ func (c *GitCommand) colorArg() string {
 	return c.Config.GetUserConfig().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.Config.GetUserConfig().Git.OverrideGpg
-	if overrideGpg {
-		return false
+func (c *GitCommand) GetConfigValue(key string) string {
+	output, err := c.OSCommand.RunCommandWithOutput("git config --get %s", key)
+	if err != nil {
+		// looks like this returns an error if there is no matching value which we're okay with
+		return ""
 	}
-
-	return c.GitConfig.GetBool("commit.gpgsign")
+	return strings.TrimSpace(output)
 }
@@ -1,10 +1,6 @@
 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/config"
 	"github.com/jesseduffield/lazygit/pkg/i18n"
@@ -18,13 +14,13 @@ func NewDummyGitCommand() *GitCommand {

 // NewDummyGitCommandWithOSCommand creates a new dummy GitCommand for testing
 func NewDummyGitCommandWithOSCommand(osCommand *oscommands.OSCommand) *GitCommand {
-	newAppConfig := config.NewDummyAppConfig()
 	return &GitCommand{
-		Log:          utils.NewDummyLog(),
-		OSCommand:    osCommand,
-		Tr:           i18n.NewTranslationSet(utils.NewDummyLog(), newAppConfig.GetUserConfig().Gui.Language),
-		Config:       newAppConfig,
-		GitConfig:    git_config.NewFakeGitConfig(map[string]string{}),
-		GetCmdWriter: func() io.Writer { return ioutil.Discard },
+		Log:                utils.NewDummyLog(),
+		OSCommand:          osCommand,
+		Tr:                 i18n.NewTranslationSet(utils.NewDummyLog()),
+		Config:             config.NewDummyAppConfig(),
+		getGlobalGitConfig: func(string) (string, error) { return "", nil },
+		getLocalGitConfig:  func(string) (string, error) { return "", nil },
+		removeFile:         func(string) error { return nil },
 	}
 }
@@ -2,59 +2,46 @@ package commands

 import (
 	"fmt"
-	"io/ioutil"
-	"os"
 	"path/filepath"
-	"strconv"
+	"strings"
 	"time"

 	"github.com/go-errors/errors"
 	"github.com/jesseduffield/lazygit/pkg/commands/models"
-	"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) OpenMergeToolCmd() string {
-	return "git mergetool"
-}
-
-func (c *GitCommand) OpenMergeTool() error {
-	return c.OSCommand.RunCommand("git mergetool")
+	return c.OSCommand.RunCommandWithOutput("%s %s", c.OSCommand.Platform.CatCmd, c.OSCommand.Quote(fileName))
 }

 // StageFile stages a file
 func (c *GitCommand) StageFile(fileName string) error {
-	return c.RunCommand("git add -- %s", c.OSCommand.Quote(fileName))
+	// renamed files look like "file1 -> file2"
+	fileNames := strings.Split(fileName, " -> ")
+	return c.OSCommand.RunCommand("git add %s", c.OSCommand.Quote(fileNames[len(fileNames)-1]))
 }

 // StageAll stages all files
 func (c *GitCommand) StageAll() error {
-	return c.RunCommand("git add -A")
+	return c.OSCommand.RunCommand("git add -A")
 }

-// UnstageAll unstages all files
+// UnstageAll stages all files
 func (c *GitCommand) UnstageAll() error {
-	return c.RunCommand("git reset")
+	return c.OSCommand.RunCommand("git reset")
 }

 // 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"
+func (c *GitCommand) UnStageFile(fileName string, tracked bool) error {
+	command := "git rm --cached --force %s"
+	if tracked {
+		command = "git reset HEAD %s"
 	}

+	// renamed files look like "file1 -> file2"
+	fileNames := strings.Split(fileName, " -> ")
 	for _, name := range fileNames {
 		if err := c.OSCommand.RunCommand(command, c.OSCommand.Quote(name)); err != nil {
 			return err
@@ -69,19 +56,20 @@ func (c *GitCommand) BeforeAndAfterFileForRename(file *models.File) (*models.Fil
 		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
+	// we've got a file that represents a rename from one file to another. Unfortunately
+	// our File abstraction fails to consider this case, so 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.
+	// again for the before file and after file. At some point we should fix the abstraction itself

+	split := strings.Split(file.Name, " -> ")
 	filesWithoutRenames := c.GetStatusFiles(GetStatusFileOptions{NoRenames: true})
 	var beforeFile *models.File
 	var afterFile *models.File
 	for _, f := range filesWithoutRenames {
-		if f.Name == file.PreviousName {
+		if f.Name == split[0] {
 			beforeFile = f
 		}
-
-		if f.Name == file.Name {
+		if f.Name == split[1] {
 			afterFile = f
 		}
 	}
@@ -117,76 +105,24 @@ func (c *GitCommand) DiscardAllFileChanges(file *models.File) error {
 		return nil
 	}

-	quotedFileName := c.OSCommand.Quote(file.Name)
-
-	if file.ShortStatus == "AA" {
-		if err := c.RunCommand("git checkout --ours --  %s", quotedFileName); err != nil {
-			return err
-		}
-		if err := c.RunCommand("git add -- %s", quotedFileName); err != nil {
-			return err
-		}
-		return nil
-	}
-
-	if file.ShortStatus == "DU" {
-		return c.RunCommand("git rm -- %s", quotedFileName)
-	}
-
 	// if the file isn't tracked, we assume you want to delete it
+	quotedFileName := c.OSCommand.Quote(file.Name)
 	if file.HasStagedChanges || file.HasMergeConflicts {
-		if err := c.RunCommand("git reset -- %s", quotedFileName); err != nil {
+		if err := c.OSCommand.RunCommand("git reset -- %s", quotedFileName); err != nil {
 			return err
 		}
 	}

-	if file.ShortStatus == "DD" || file.ShortStatus == "AU" {
-		return nil
-	}
-
-	if file.Added {
-		return c.OSCommand.RemoveFile(file.Name)
+	if !file.Tracked {
+		return c.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.RunCommand("git checkout -- %s", quotedPath); 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.RunCommand("git checkout -- %s", quotedFileName)
+	return c.OSCommand.RunCommand("git checkout -- %s", quotedFileName)
 }

 // Ignore adds a file to the gitignore for the repo
@@ -195,36 +131,33 @@ func (c *GitCommand) Ignore(filename string) error {
 }

 // WorktreeFileDiff returns the diff of a file
-func (c *GitCommand) WorktreeFileDiff(file *models.File, plain bool, cached bool, ignoreWhitespace bool) string {
+func (c *GitCommand) WorktreeFileDiff(file *models.File, plain bool, cached bool) string {
 	// for now we assume an error means the file was deleted
-	s, _ := c.OSCommand.RunCommandWithOutput(c.WorktreeFileDiffCmdStr(file, plain, cached, ignoreWhitespace))
+	s, _ := c.OSCommand.RunCommandWithOutput(c.WorktreeFileDiffCmdStr(file, plain, cached))
 	return s
 }

-func (c *GitCommand) WorktreeFileDiffCmdStr(node models.IFile, plain bool, cached bool, ignoreWhitespace bool) string {
+func (c *GitCommand) WorktreeFileDiffCmdStr(file *models.File, plain bool, cached bool) string {
 	cachedArg := ""
 	trackedArg := "--"
 	colorArg := c.colorArg()
-	quotedPath := c.OSCommand.Quote(node.GetPath())
-	ignoreWhitespaceArg := ""
+	split := strings.Split(file.Name, " -> ") // in case of a renamed file we get the new filename
+	fileName := c.OSCommand.Quote(split[len(split)-1])
 	if cached {
 		cachedArg = "--cached"
 	}
-	if !node.GetIsTracked() && !node.GetHasStagedChanges() && !cached {
-		trackedArg = "--no-index -- /dev/null"
+	if !file.Tracked && !file.HasStagedChanges && !cached {
+		trackedArg = "--no-index /dev/null"
 	}
 	if plain {
 		colorArg = "never"
 	}
-	if ignoreWhitespace {
-		ignoreWhitespaceArg = "--ignore-all-space"
-	}

-	return fmt.Sprintf("git diff --submodule --no-ext-diff --color=%s %s %s %s %s", colorArg, ignoreWhitespaceArg, cachedArg, trackedArg, quotedPath)
+	return fmt.Sprintf("git diff --submodule --no-ext-diff --color=%s %s %s %s", colorArg, cachedArg, trackedArg, fileName)
 }

 func (c *GitCommand) ApplyPatch(patch string, flags ...string) error {
-	filepath := filepath.Join(c.Config.GetTempDir(), utils.GetCurrentRepoName(), time.Now().Format("Jan _2 15.04.05.000000000")+".patch")
+	filepath := filepath.Join(c.Config.GetUserConfigDir(), 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
@@ -235,7 +168,7 @@ func (c *GitCommand) ApplyPatch(patch string, flags ...string) error {
 		flagStr += " --" + flag
 	}

-	return c.RunCommand("git apply %s %s", flagStr, c.OSCommand.Quote(filepath))
+	return c.OSCommand.RunCommand("git apply %s %s", flagStr, c.OSCommand.Quote(filepath))
 }

 // ShowFileDiff get the diff of specified from and to. Typically this will be used for a single commit so it'll be 123abc^..123abc
@@ -256,12 +189,12 @@ func (c *GitCommand) ShowFileDiffCmdStr(from string, to string, reverse bool, fi
 		reverseFlag = " -R "
 	}

-	return fmt.Sprintf("git diff --submodule --no-ext-diff --no-renames --color=%s %s %s %s -- %s", colorArg, from, to, reverseFlag, c.OSCommand.Quote(fileName))
+	return fmt.Sprintf("git diff --submodule --no-ext-diff --no-renames --color=%s %s %s %s -- %s", colorArg, from, to, reverseFlag, fileName)
 }

 // CheckoutFile checks out the file for the given commit
 func (c *GitCommand) CheckoutFile(commitSha, fileName string) error {
-	return c.RunCommand("git checkout %s -- %s", commitSha, c.OSCommand.Quote(fileName))
+	return c.OSCommand.RunCommand("git checkout %s %s", commitSha, fileName)
 }

 // DiscardOldFileChanges discards changes to a file from an old commit
@@ -271,7 +204,7 @@ func (c *GitCommand) DiscardOldFileChanges(commits []*models.Commit, commitIndex
 	}

 	// check if file exists in previous commit (this command returns an error if the file doesn't exist)
-	if err := c.RunCommand("git cat-file -e HEAD^:%s", c.OSCommand.Quote(fileName)); err != nil {
+	if err := c.OSCommand.RunCommand("git cat-file -e HEAD^:%s", fileName); err != nil {
 		if err := c.OSCommand.Remove(fileName); err != nil {
 			return err
 		}
@@ -283,7 +216,10 @@ func (c *GitCommand) DiscardOldFileChanges(commits []*models.Commit, commitIndex
 	}

 	// amend the commit
-	err := c.AmendHead()
+	cmd, err := c.AmendHead()
+	if cmd != nil {
+		return errors.New("received unexpected pointer to cmd")
+	}
 	if err != nil {
 		return err
 	}
@@ -294,17 +230,17 @@ func (c *GitCommand) DiscardOldFileChanges(commits []*models.Commit, commitIndex

 // DiscardAnyUnstagedFileChanges discards any unstages file changes via `git checkout -- .`
 func (c *GitCommand) DiscardAnyUnstagedFileChanges() error {
-	return c.RunCommand("git checkout -- .")
+	return c.OSCommand.RunCommand("git checkout -- .")
 }

 // RemoveTrackedFiles will delete the given file(s) even if they are currently tracked
 func (c *GitCommand) RemoveTrackedFiles(name string) error {
-	return c.RunCommand("git rm -r --cached -- %s", c.OSCommand.Quote(name))
+	return c.OSCommand.RunCommand("git rm -r --cached %s", name)
 }

 // RemoveUntrackedFiles runs `git clean -fd`
 func (c *GitCommand) RemoveUntrackedFiles() error {
-	return c.RunCommand("git clean -fd")
+	return c.OSCommand.RunCommand("git clean -fd")
 }

 // ResetAndClean removes all unstaged changes and removes all untracked files
@@ -326,38 +262,3 @@ func (c *GitCommand) ResetAndClean() error {

 	return c.RemoveUntrackedFiles()
 }
-
-func (c *GitCommand) EditFileCmdStr(filename string, lineNumber int) (string, error) {
-	editor := c.Config.GetUserConfig().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.RunCommand("which vi"); 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.Config.GetUserConfig().OS.EditCommandTemplate
-	return utils.ResolvePlaceholderString(editCmdTemplate, templateValues), nil
-}
@@ -1,878 +0,0 @@
-package commands
-
-import (
-	"fmt"
-	"io/ioutil"
-	"os/exec"
-	"testing"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/git_config"
-	"github.com/jesseduffield/lazygit/pkg/commands/models"
-	"github.com/jesseduffield/lazygit/pkg/secureexec"
-	"github.com/jesseduffield/lazygit/pkg/test"
-	"github.com/stretchr/testify/assert"
-)
-
-// TestGitCommandStageFile is a function.
-func TestGitCommandStageFile(t *testing.T) {
-	gitCmd := NewDummyGitCommand()
-	gitCmd.OSCommand.Command = func(cmd string, args ...string) *exec.Cmd {
-		assert.EqualValues(t, "git", cmd)
-		assert.EqualValues(t, []string{"add", "--", "test.txt"}, args)
-
-		return secureexec.Command("echo")
-	}
-
-	assert.NoError(t, gitCmd.StageFile("test.txt"))
-}
-
-// TestGitCommandUnstageFile is a function.
-func TestGitCommandUnstageFile(t *testing.T) {
-	type scenario struct {
-		testName string
-		command  func(string, ...string) *exec.Cmd
-		test     func(error)
-		reset    bool
-	}
-
-	scenarios := []scenario{
-		{
-			"Remove an untracked file from staging",
-			func(cmd string, args ...string) *exec.Cmd {
-				assert.EqualValues(t, "git", cmd)
-				assert.EqualValues(t, []string{"rm", "--cached", "--force", "--", "test.txt"}, args)
-
-				return secureexec.Command("echo")
-			},
-			func(err error) {
-				assert.NoError(t, err)
-			},
-			false,
-		},
-		{
-			"Remove a tracked file from staging",
-			func(cmd string, args ...string) *exec.Cmd {
-				assert.EqualValues(t, "git", cmd)
-				assert.EqualValues(t, []string{"reset", "HEAD", "--", "test.txt"}, args)
-
-				return secureexec.Command("echo")
-			},
-			func(err error) {
-				assert.NoError(t, err)
-			},
-			true,
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommand()
-			gitCmd.OSCommand.Command = s.command
-			s.test(gitCmd.UnStageFile([]string{"test.txt"}, s.reset))
-		})
-	}
-}
-
-// TestGitCommandDiscardAllFileChanges is a function.
-// 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) {
-	type scenario struct {
-		testName   string
-		command    func() (func(string, ...string) *exec.Cmd, *[][]string)
-		test       func(*[][]string, error)
-		file       *models.File
-		removeFile func(string) error
-	}
-
-	scenarios := []scenario{
-		{
-			"An error occurred when resetting",
-			func() (func(string, ...string) *exec.Cmd, *[][]string) {
-				cmdsCalled := [][]string{}
-				return func(cmd string, args ...string) *exec.Cmd {
-					cmdsCalled = append(cmdsCalled, args)
-
-					return secureexec.Command("test")
-				}, &cmdsCalled
-			},
-			func(cmdsCalled *[][]string, err error) {
-				assert.Error(t, err)
-				assert.Len(t, *cmdsCalled, 1)
-				assert.EqualValues(t, *cmdsCalled, [][]string{
-					{"reset", "--", "test"},
-				})
-			},
-			&models.File{
-				Name:             "test",
-				HasStagedChanges: true,
-			},
-			func(string) error {
-				return nil
-			},
-		},
-		{
-			"An error occurred when removing file",
-			func() (func(string, ...string) *exec.Cmd, *[][]string) {
-				cmdsCalled := [][]string{}
-				return func(cmd string, args ...string) *exec.Cmd {
-					cmdsCalled = append(cmdsCalled, args)
-
-					return secureexec.Command("test")
-				}, &cmdsCalled
-			},
-			func(cmdsCalled *[][]string, err error) {
-				assert.Error(t, err)
-				assert.EqualError(t, err, "an error occurred when removing file")
-				assert.Len(t, *cmdsCalled, 0)
-			},
-			&models.File{
-				Name:    "test",
-				Tracked: false,
-				Added:   true,
-			},
-			func(string) error {
-				return fmt.Errorf("an error occurred when removing file")
-			},
-		},
-		{
-			"An error occurred with checkout",
-			func() (func(string, ...string) *exec.Cmd, *[][]string) {
-				cmdsCalled := [][]string{}
-				return func(cmd string, args ...string) *exec.Cmd {
-					cmdsCalled = append(cmdsCalled, args)
-
-					return secureexec.Command("test")
-				}, &cmdsCalled
-			},
-			func(cmdsCalled *[][]string, err error) {
-				assert.Error(t, err)
-				assert.Len(t, *cmdsCalled, 1)
-				assert.EqualValues(t, *cmdsCalled, [][]string{
-					{"checkout", "--", "test"},
-				})
-			},
-			&models.File{
-				Name:             "test",
-				Tracked:          true,
-				HasStagedChanges: false,
-			},
-			func(string) error {
-				return nil
-			},
-		},
-		{
-			"Checkout only",
-			func() (func(string, ...string) *exec.Cmd, *[][]string) {
-				cmdsCalled := [][]string{}
-				return func(cmd string, args ...string) *exec.Cmd {
-					cmdsCalled = append(cmdsCalled, args)
-
-					return secureexec.Command("echo")
-				}, &cmdsCalled
-			},
-			func(cmdsCalled *[][]string, err error) {
-				assert.NoError(t, err)
-				assert.Len(t, *cmdsCalled, 1)
-				assert.EqualValues(t, *cmdsCalled, [][]string{
-					{"checkout", "--", "test"},
-				})
-			},
-			&models.File{
-				Name:             "test",
-				Tracked:          true,
-				HasStagedChanges: false,
-			},
-			func(string) error {
-				return nil
-			},
-		},
-		{
-			"Reset and checkout staged changes",
-			func() (func(string, ...string) *exec.Cmd, *[][]string) {
-				cmdsCalled := [][]string{}
-				return func(cmd string, args ...string) *exec.Cmd {
-					cmdsCalled = append(cmdsCalled, args)
-
-					return secureexec.Command("echo")
-				}, &cmdsCalled
-			},
-			func(cmdsCalled *[][]string, err error) {
-				assert.NoError(t, err)
-				assert.Len(t, *cmdsCalled, 2)
-				assert.EqualValues(t, *cmdsCalled, [][]string{
-					{"reset", "--", "test"},
-					{"checkout", "--", "test"},
-				})
-			},
-			&models.File{
-				Name:             "test",
-				Tracked:          true,
-				HasStagedChanges: true,
-			},
-			func(string) error {
-				return nil
-			},
-		},
-		{
-			"Reset and checkout merge conflicts",
-			func() (func(string, ...string) *exec.Cmd, *[][]string) {
-				cmdsCalled := [][]string{}
-				return func(cmd string, args ...string) *exec.Cmd {
-					cmdsCalled = append(cmdsCalled, args)
-
-					return secureexec.Command("echo")
-				}, &cmdsCalled
-			},
-			func(cmdsCalled *[][]string, err error) {
-				assert.NoError(t, err)
-				assert.Len(t, *cmdsCalled, 2)
-				assert.EqualValues(t, *cmdsCalled, [][]string{
-					{"reset", "--", "test"},
-					{"checkout", "--", "test"},
-				})
-			},
-			&models.File{
-				Name:              "test",
-				Tracked:           true,
-				HasMergeConflicts: true,
-			},
-			func(string) error {
-				return nil
-			},
-		},
-		{
-			"Reset and remove",
-			func() (func(string, ...string) *exec.Cmd, *[][]string) {
-				cmdsCalled := [][]string{}
-				return func(cmd string, args ...string) *exec.Cmd {
-					cmdsCalled = append(cmdsCalled, args)
-
-					return secureexec.Command("echo")
-				}, &cmdsCalled
-			},
-			func(cmdsCalled *[][]string, err error) {
-				assert.NoError(t, err)
-				assert.Len(t, *cmdsCalled, 1)
-				assert.EqualValues(t, *cmdsCalled, [][]string{
-					{"reset", "--", "test"},
-				})
-			},
-			&models.File{
-				Name:             "test",
-				Tracked:          false,
-				Added:            true,
-				HasStagedChanges: true,
-			},
-			func(filename string) error {
-				assert.Equal(t, "test", filename)
-				return nil
-			},
-		},
-		{
-			"Remove only",
-			func() (func(string, ...string) *exec.Cmd, *[][]string) {
-				cmdsCalled := [][]string{}
-				return func(cmd string, args ...string) *exec.Cmd {
-					cmdsCalled = append(cmdsCalled, args)
-
-					return secureexec.Command("echo")
-				}, &cmdsCalled
-			},
-			func(cmdsCalled *[][]string, err error) {
-				assert.NoError(t, err)
-				assert.Len(t, *cmdsCalled, 0)
-			},
-			&models.File{
-				Name:             "test",
-				Tracked:          false,
-				Added:            true,
-				HasStagedChanges: false,
-			},
-			func(filename string) error {
-				assert.Equal(t, "test", filename)
-				return nil
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			var cmdsCalled *[][]string
-			gitCmd := NewDummyGitCommand()
-			gitCmd.OSCommand.Command, cmdsCalled = s.command()
-			gitCmd.OSCommand.SetRemoveFile(s.removeFile)
-			s.test(cmdsCalled, gitCmd.DiscardAllFileChanges(s.file))
-		})
-	}
-}
-
-// TestGitCommandDiff is a function.
-func TestGitCommandDiff(t *testing.T) {
-	type scenario struct {
-		testName         string
-		command          func(string, ...string) *exec.Cmd
-		file             *models.File
-		plain            bool
-		cached           bool
-		ignoreWhitespace bool
-	}
-
-	scenarios := []scenario{
-		{
-			"Default case",
-			func(cmd string, args ...string) *exec.Cmd {
-				assert.EqualValues(t, "git", cmd)
-				assert.EqualValues(t, []string{"diff", "--submodule", "--no-ext-diff", "--color=always", "--", "test.txt"}, args)
-
-				return secureexec.Command("echo")
-			},
-			&models.File{
-				Name:             "test.txt",
-				HasStagedChanges: false,
-				Tracked:          true,
-			},
-			false,
-			false,
-			false,
-		},
-		{
-			"cached",
-			func(cmd string, args ...string) *exec.Cmd {
-				assert.EqualValues(t, "git", cmd)
-				assert.EqualValues(t, []string{"diff", "--submodule", "--no-ext-diff", "--color=always", "--cached", "--", "test.txt"}, args)
-
-				return secureexec.Command("echo")
-			},
-			&models.File{
-				Name:             "test.txt",
-				HasStagedChanges: false,
-				Tracked:          true,
-			},
-			false,
-			true,
-			false,
-		},
-		{
-			"plain",
-			func(cmd string, args ...string) *exec.Cmd {
-				assert.EqualValues(t, "git", cmd)
-				assert.EqualValues(t, []string{"diff", "--submodule", "--no-ext-diff", "--color=never", "--", "test.txt"}, args)
-
-				return secureexec.Command("echo")
-			},
-			&models.File{
-				Name:             "test.txt",
-				HasStagedChanges: false,
-				Tracked:          true,
-			},
-			true,
-			false,
-			false,
-		},
-		{
-			"File not tracked and file has no staged changes",
-			func(cmd string, args ...string) *exec.Cmd {
-				assert.EqualValues(t, "git", cmd)
-				assert.EqualValues(t, []string{"diff", "--submodule", "--no-ext-diff", "--color=always", "--no-index", "--", "/dev/null", "test.txt"}, args)
-
-				return secureexec.Command("echo")
-			},
-			&models.File{
-				Name:             "test.txt",
-				HasStagedChanges: false,
-				Tracked:          false,
-			},
-			false,
-			false,
-			false,
-		},
-		{
-			"Default case (ignore whitespace)",
-			func(cmd string, args ...string) *exec.Cmd {
-				assert.EqualValues(t, "git", cmd)
-				assert.EqualValues(t, []string{"diff", "--submodule", "--no-ext-diff", "--color=always", "--ignore-all-space", "--", "test.txt"}, args)
-
-				return secureexec.Command("echo")
-			},
-			&models.File{
-				Name:             "test.txt",
-				HasStagedChanges: false,
-				Tracked:          true,
-			},
-			false,
-			false,
-			true,
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommand()
-			gitCmd.OSCommand.Command = s.command
-			gitCmd.WorktreeFileDiff(s.file, s.plain, s.cached, s.ignoreWhitespace)
-		})
-	}
-}
-
-// TestGitCommandCheckoutFile is a function.
-func TestGitCommandCheckoutFile(t *testing.T) {
-	type scenario struct {
-		testName  string
-		commitSha string
-		fileName  string
-		command   func(string, ...string) *exec.Cmd
-		test      func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			"typical case",
-			"11af912",
-			"test999.txt",
-			test.CreateMockCommand(t, []*test.CommandSwapper{
-				{
-					Expect:  "git checkout 11af912 -- test999.txt",
-					Replace: "echo",
-				},
-			}),
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			"returns error if there is one",
-			"11af912",
-			"test999.txt",
-			test.CreateMockCommand(t, []*test.CommandSwapper{
-				{
-					Expect:  "git checkout 11af912 -- test999.txt",
-					Replace: "test",
-				},
-			}),
-			func(err error) {
-				assert.Error(t, err)
-			},
-		},
-	}
-
-	gitCmd := NewDummyGitCommand()
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd.OSCommand.Command = s.command
-			s.test(gitCmd.CheckoutFile(s.commitSha, s.fileName))
-		})
-	}
-}
-
-func TestGitCommandApplyPatch(t *testing.T) {
-	type scenario struct {
-		testName string
-		command  func(string, ...string) *exec.Cmd
-		test     func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			"valid case",
-			func(cmd string, args ...string) *exec.Cmd {
-				assert.Equal(t, "git", cmd)
-				assert.EqualValues(t, []string{"apply", "--cached"}, args[0:2])
-				filename := args[2]
-				content, err := ioutil.ReadFile(filename)
-				assert.NoError(t, err)
-
-				assert.Equal(t, "test", string(content))
-
-				return secureexec.Command("echo", "done")
-			},
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			"command returns error",
-			func(cmd string, args ...string) *exec.Cmd {
-				assert.Equal(t, "git", cmd)
-				assert.EqualValues(t, []string{"apply", "--cached"}, args[0:2])
-				filename := args[2]
-				// TODO: Ideally we want to mock out OSCommand here so that we're not
-				// double handling testing it's CreateTempFile functionality,
-				// but it is going to take a bit of work to make a proper mock for it
-				// so I'm leaving it for another PR
-				content, err := ioutil.ReadFile(filename)
-				assert.NoError(t, err)
-
-				assert.Equal(t, "test", string(content))
-
-				return secureexec.Command("test")
-			},
-			func(err error) {
-				assert.Error(t, err)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommand()
-			gitCmd.OSCommand.Command = s.command
-			s.test(gitCmd.ApplyPatch("test", "cached"))
-		})
-	}
-}
-
-func TestGitCommandDiscardOldFileChanges(t *testing.T) {
-	type scenario struct {
-		testName               string
-		gitConfigMockResponses map[string]string
-		commits                []*models.Commit
-		commitIndex            int
-		fileName               string
-		command                func(string, ...string) *exec.Cmd
-		test                   func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			"returns error when index outside of range of commits",
-			nil,
-			[]*models.Commit{},
-			0,
-			"test999.txt",
-			nil,
-			func(err error) {
-				assert.Error(t, err)
-			},
-		},
-		{
-			"returns error when using gpg",
-			map[string]string{"commit.gpgsign": "true"},
-			[]*models.Commit{{Name: "commit", Sha: "123456"}},
-			0,
-			"test999.txt",
-			nil,
-			func(err error) {
-				assert.Error(t, err)
-			},
-		},
-		{
-			"checks out file if it already existed",
-			nil,
-			[]*models.Commit{
-				{Name: "commit", Sha: "123456"},
-				{Name: "commit2", Sha: "abcdef"},
-			},
-			0,
-			"test999.txt",
-			test.CreateMockCommand(t, []*test.CommandSwapper{
-				{
-					Expect:  "git rebase --interactive --autostash --keep-empty abcdef",
-					Replace: "echo",
-				},
-				{
-					Expect:  "git cat-file -e HEAD^:test999.txt",
-					Replace: "echo",
-				},
-				{
-					Expect:  "git checkout HEAD^ -- test999.txt",
-					Replace: "echo",
-				},
-				{
-					Expect:  "git commit --amend --no-edit --allow-empty",
-					Replace: "echo",
-				},
-				{
-					Expect:  "git rebase --continue",
-					Replace: "echo",
-				},
-			}),
-			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
-	}
-
-	gitCmd := NewDummyGitCommand()
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd.OSCommand.Command = s.command
-			gitCmd.GitConfig = git_config.NewFakeGitConfig(s.gitConfigMockResponses)
-			s.test(gitCmd.DiscardOldFileChanges(s.commits, s.commitIndex, s.fileName))
-		})
-	}
-}
-
-// TestGitCommandDiscardUnstagedFileChanges is a function.
-func TestGitCommandDiscardUnstagedFileChanges(t *testing.T) {
-	type scenario struct {
-		testName string
-		file     *models.File
-		command  func(string, ...string) *exec.Cmd
-		test     func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			"valid case",
-			&models.File{Name: "test.txt"},
-			test.CreateMockCommand(t, []*test.CommandSwapper{
-				{
-					Expect:  `git checkout -- "test.txt"`,
-					Replace: "echo",
-				},
-			}),
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-	}
-
-	gitCmd := NewDummyGitCommand()
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd.OSCommand.Command = s.command
-			s.test(gitCmd.DiscardUnstagedFileChanges(s.file))
-		})
-	}
-}
-
-// TestGitCommandDiscardAnyUnstagedFileChanges is a function.
-func TestGitCommandDiscardAnyUnstagedFileChanges(t *testing.T) {
-	type scenario struct {
-		testName string
-		command  func(string, ...string) *exec.Cmd
-		test     func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			"valid case",
-			test.CreateMockCommand(t, []*test.CommandSwapper{
-				{
-					Expect:  `git checkout -- .`,
-					Replace: "echo",
-				},
-			}),
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-	}
-
-	gitCmd := NewDummyGitCommand()
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd.OSCommand.Command = s.command
-			s.test(gitCmd.DiscardAnyUnstagedFileChanges())
-		})
-	}
-}
-
-// TestGitCommandRemoveUntrackedFiles is a function.
-func TestGitCommandRemoveUntrackedFiles(t *testing.T) {
-	type scenario struct {
-		testName string
-		command  func(string, ...string) *exec.Cmd
-		test     func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			"valid case",
-			test.CreateMockCommand(t, []*test.CommandSwapper{
-				{
-					Expect:  `git clean -fd`,
-					Replace: "echo",
-				},
-			}),
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-	}
-
-	gitCmd := NewDummyGitCommand()
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd.OSCommand.Command = s.command
-			s.test(gitCmd.RemoveUntrackedFiles())
-		})
-	}
-}
-
-// TestEditFileCmdStr is a function.
-func TestEditFileCmdStr(t *testing.T) {
-	gitCmd := NewDummyGitCommand()
-
-	type scenario struct {
-		filename                  string
-		configEditCommand         string
-		configEditCommandTemplate string
-		command                   func(string, ...string) *exec.Cmd
-		getenv                    func(string) string
-		gitConfigMockResponses    map[string]string
-		test                      func(string, error)
-	}
-
-	scenarios := []scenario{
-		{
-			"test",
-			"",
-			"{{editor}} {{filename}}",
-			func(name string, arg ...string) *exec.Cmd {
-				return secureexec.Command("exit", "1")
-			},
-			func(env string) string {
-				return ""
-			},
-			nil,
-			func(cmdStr string, err error) {
-				assert.EqualError(t, err, "No editor defined in config file, $GIT_EDITOR, $VISUAL, $EDITOR, or git config")
-			},
-		},
-		{
-			"test",
-			"nano",
-			"{{editor}} {{filename}}",
-			func(name string, args ...string) *exec.Cmd {
-				assert.Equal(t, "which", name)
-				return secureexec.Command("echo")
-			},
-			func(env string) string {
-				return ""
-			},
-			nil,
-			func(cmdStr string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "nano "+gitCmd.OSCommand.Quote("test"), cmdStr)
-			},
-		},
-		{
-			"test",
-			"",
-			"{{editor}} {{filename}}",
-			func(name string, arg ...string) *exec.Cmd {
-				assert.Equal(t, "which", name)
-				return secureexec.Command("exit", "1")
-			},
-			func(env string) string {
-				return ""
-			},
-			map[string]string{"core.editor": "nano"},
-			func(cmdStr string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "nano "+gitCmd.OSCommand.Quote("test"), cmdStr)
-			},
-		},
-		{
-			"test",
-			"",
-			"{{editor}} {{filename}}",
-			func(name string, arg ...string) *exec.Cmd {
-				assert.Equal(t, "which", name)
-				return secureexec.Command("exit", "1")
-			},
-			func(env string) string {
-				if env == "VISUAL" {
-					return "nano"
-				}
-
-				return ""
-			},
-			nil,
-			func(cmdStr string, err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			"test",
-			"",
-			"{{editor}} {{filename}}",
-			func(name string, arg ...string) *exec.Cmd {
-				assert.Equal(t, "which", name)
-				return secureexec.Command("exit", "1")
-			},
-			func(env string) string {
-				if env == "EDITOR" {
-					return "emacs"
-				}
-
-				return ""
-			},
-			nil,
-			func(cmdStr string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "emacs "+gitCmd.OSCommand.Quote("test"), cmdStr)
-			},
-		},
-		{
-			"test",
-			"",
-			"{{editor}} {{filename}}",
-			func(name string, arg ...string) *exec.Cmd {
-				assert.Equal(t, "which", name)
-				return secureexec.Command("echo")
-			},
-			func(env string) string {
-				return ""
-			},
-			nil,
-			func(cmdStr string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "vi "+gitCmd.OSCommand.Quote("test"), cmdStr)
-			},
-		},
-		{
-			"file/with space",
-			"",
-			"{{editor}} {{filename}}",
-			func(name string, args ...string) *exec.Cmd {
-				assert.Equal(t, "which", name)
-				return secureexec.Command("echo")
-			},
-			func(env string) string {
-				return ""
-			},
-			nil,
-			func(cmdStr string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "vi "+gitCmd.OSCommand.Quote("file/with space"), cmdStr)
-			},
-		},
-		{
-			"open file/at line",
-			"vim",
-			"{{editor}} +{{line}} {{filename}}",
-			func(name string, args ...string) *exec.Cmd {
-				assert.Equal(t, "which", name)
-				return secureexec.Command("echo")
-			},
-			func(env string) string {
-				return ""
-			},
-			nil,
-			func(cmdStr string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "vim +1 "+gitCmd.OSCommand.Quote("open file/at line"), cmdStr)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		gitCmd.Config.GetUserConfig().OS.EditCommand = s.configEditCommand
-		gitCmd.Config.GetUserConfig().OS.EditCommandTemplate = s.configEditCommandTemplate
-		gitCmd.OSCommand.Command = s.command
-		gitCmd.OSCommand.Getenv = s.getenv
-		gitCmd.GitConfig = git_config.NewFakeGitConfig(s.gitConfigMockResponses)
-		s.test(gitCmd.EditFileCmdStr(s.filename, 1))
-	}
-}
@@ -1,17 +1,14 @@
 package commands

 import (
-	"io"
 	"io/ioutil"
 	"os"
 	"path/filepath"
 	"strings"
-	"time"

 	"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/oscommands"
 	"github.com/jesseduffield/lazygit/pkg/commands/patch"
 	"github.com/jesseduffield/lazygit/pkg/config"
@@ -19,6 +16,7 @@ import (
 	"github.com/jesseduffield/lazygit/pkg/i18n"
 	"github.com/jesseduffield/lazygit/pkg/utils"
 	"github.com/sirupsen/logrus"
+	gitconfig "github.com/tcnksm/go-gitconfig"
 )

 // this takes something like:
@@ -34,37 +32,38 @@ type GitCommand struct {
 	Repo                 *gogit.Repository
 	Tr                   *i18n.TranslationSet
 	Config               config.AppConfigurer
+	getGlobalGitConfig   func(string) (string, error)
+	getLocalGitConfig    func(string) (string, error)
+	removeFile           func(string) error
 	DotGitDir            string
 	onSuccessfulContinue func() error
 	PatchManager         *patch.PatchManager
-	GitConfig            git_config.IGitConfig

 	// 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
 }

 // NewGitCommand it runs git commands
-func NewGitCommand(
-	log *logrus.Entry,
-	osCommand *oscommands.OSCommand,
-	tr *i18n.TranslationSet,
-	config config.AppConfigurer,
-	gitConfig git_config.IGitConfig,
-) (*GitCommand, error) {
+func NewGitCommand(log *logrus.Entry, osCommand *oscommands.OSCommand, tr *i18n.TranslationSet, config config.AppConfigurer) (*GitCommand, error) {
 	var repo *gogit.Repository

-	pushToCurrent := gitConfig.Get("push.default") == "current"
+	// see what our default push behaviour is
+	output, err := osCommand.RunCommandWithOutput("git config --get push.default")
+	pushToCurrent := false
+	if err != nil {
+		log.Errorf("error reading git config: %v", err)
+	} else {
+		pushToCurrent = strings.TrimSpace(output) == "current"
+	}
+
+	if err := verifyInGitRepo(osCommand.RunCommand); err != nil {
+		return nil, err
+	}

 	if err := navigateToRepoRootDirectory(os.Stat, os.Chdir); err != nil {
 		return nil, err
 	}

-	var err error
 	if repo, err = setupRepository(gogit.PlainOpen, tr.GitconfigParseErr); err != nil {
 		return nil, err
 	}
@@ -75,15 +74,16 @@ func NewGitCommand(
 	}

 	gitCommand := &GitCommand{
-		Log:           log,
-		OSCommand:     osCommand,
-		Tr:            tr,
-		Repo:          repo,
-		Config:        config,
-		DotGitDir:     dotGitDir,
-		PushToCurrent: pushToCurrent,
-		GitConfig:     gitConfig,
-		GetCmdWriter:  func() io.Writer { return ioutil.Discard },
+		Log:                log,
+		OSCommand:          osCommand,
+		Tr:                 tr,
+		Repo:               repo,
+		Config:             config,
+		getGlobalGitConfig: gitconfig.Global,
+		getLocalGitConfig:  gitconfig.Local,
+		removeFile:         os.RemoveAll,
+		DotGitDir:          dotGitDir,
+		PushToCurrent:      pushToCurrent,
 	}

 	gitCommand.PatchManager = patch.NewPatchManager(log, gitCommand.ApplyPatch, gitCommand.ShowFileDiff)
@@ -91,25 +91,8 @@ func NewGitCommand(
 	return gitCommand, 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
-	}
-
-	newGitCommand := &GitCommand{}
-	*newGitCommand = *c
-	newGitCommand.OSCommand = c.OSCommand.WithSpan(span)
-
-	// 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 verifyInGitRepo(runCmd func(string, ...interface{}) error) error {
+	return runCmd("git status")
 }

 func navigateToRepoRootDirectory(stat func(string) (os.FileInfo, error), chdir func(string) error) error {
@@ -140,18 +123,6 @@ func navigateToRepoRootDirectory(stat func(string) (os.FileInfo, error), chdir f
 		if err = chdir(".."); err != nil {
 			return utils.WrapError(err)
 		}
-
-		currentPath, err := os.Getwd()
-		if err != nil {
-			return err
-		}
-
-		atRoot := currentPath == filepath.Dir(currentPath)
-		if atRoot {
-			// we should never really land here: the code that creates GitCommand should
-			// verify we're in a git directory
-			return errors.New("Must open lazygit in a git repository")
-		}
 	}
 }

@@ -221,40 +192,3 @@ func findDotGitDir(stat func(string) (os.FileInfo, error), readFile func(filenam
 	}
 	return strings.TrimSpace(strings.TrimPrefix(fileContent, "gitdir: ")), nil
 }
-
-func VerifyInGitRepo(osCommand *oscommands.OSCommand) error {
-	return osCommand.RunCommand("git rev-parse --git-dir")
-}
-
-func (c *GitCommand) RunCommand(formatString string, formatArgs ...interface{}) error {
-	_, err := c.RunCommandWithOutput(formatString, formatArgs...)
-	return err
-}
-
-func (c *GitCommand) RunCommandWithOutput(formatString string, formatArgs ...interface{}) (string, error) {
-	// TODO: have this retry logic in other places we run the command
-	waitTime := 50 * time.Millisecond
-	retryCount := 5
-	attempt := 0
-
-	for {
-		output, err := c.OSCommand.RunCommandWithOutput(formatString, formatArgs...)
-		if err != nil {
-			// if we have an error based on the index lock, we should wait a bit and then retry
-			if strings.Contains(output, ".git/index.lock") {
-				c.Log.Error(output)
-				c.Log.Info("index.lock prevented command from running. Retrying command after a small wait")
-				attempt++
-				time.Sleep(waitTime)
-				if attempt < retryCount {
-					continue
-				}
-			}
-		}
-		return output, err
-	}
-}
-
-func (c *GitCommand) NewCmdObjFromStr(cmdStr string) oscommands.ICmdObj {
-	return c.OSCommand.NewCmdObjFromStr(cmdStr).AddEnvVars("GIT_OPTIONAL_LOCKS=0")
-}
@@ -1,59 +0,0 @@
-package git_config
-
-import (
-	"strings"
-
-	"github.com/sirupsen/logrus"
-)
-
-type IGitConfig interface {
-	Get(string) string
-	GetBool(string) bool
-}
-
-type CachedGitConfig struct {
-	cache  map[string]string
-	getKey func(string) (string, error)
-	log    *logrus.Entry
-}
-
-func NewStdCachedGitConfig(log *logrus.Entry) *CachedGitConfig {
-	return NewCachedGitConfig(getGitConfigValue, log)
-}
-
-func NewCachedGitConfig(getKey func(string) (string, error), log *logrus.Entry) *CachedGitConfig {
-	return &CachedGitConfig{
-		cache:  make(map[string]string),
-		getKey: getKey,
-		log:    log,
-	}
-}
-
-func (self *CachedGitConfig) Get(key string) string {
-	if value, ok := self.cache[key]; ok {
-		self.log.Debugf("using cache for key " + key)
-		return value
-	}
-
-	value := self.getAux(key)
-	self.cache[key] = value
-	return value
-}
-
-func (self *CachedGitConfig) getAux(key string) string {
-	value, err := self.getKey(key)
-	if err != nil {
-		self.log.Debugf("Error getting git config value for key: " + key + ". Error: " + err.Error())
-		return ""
-	}
-	return strings.TrimSpace(value)
-}
-
-func (self *CachedGitConfig) GetBool(key string) bool {
-	return isTruthy(self.Get(key))
-}
-
-func isTruthy(value string) bool {
-	lcValue := strings.ToLower(value)
-	return lcValue == "true" || lcValue == "1" || lcValue == "yes" || lcValue == "on"
-}
@@ -1,116 +0,0 @@
-package git_config
-
-import (
-	"testing"
-
-	"github.com/jesseduffield/lazygit/pkg/utils"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestGetBool(t *testing.T) {
-	type scenario struct {
-		testName      string
-		mockResponses map[string]string
-		expected      bool
-	}
-
-	scenarios := []scenario{
-		{
-			"Option global and local config commit.gpgsign is not set",
-			map[string]string{},
-			false,
-		},
-		{
-			"Some other random key is set",
-			map[string]string{"blah": "blah"},
-			false,
-		},
-		{
-			"Option commit.gpgsign is true",
-			map[string]string{"commit.gpgsign": "True"},
-			true,
-		},
-		{
-			"Option commit.gpgsign is on",
-			map[string]string{"commit.gpgsign": "ON"},
-			true,
-		},
-		{
-			"Option commit.gpgsign is yes",
-			map[string]string{"commit.gpgsign": "YeS"},
-			true,
-		},
-		{
-			"Option commit.gpgsign is 1",
-			map[string]string{"commit.gpgsign": "1"},
-			true,
-		},
-	}
-
-	for _, s := range scenarios {
-		s := s
-		t.Run(s.testName, func(t *testing.T) {
-			fake := NewFakeGitConfig(s.mockResponses)
-			real := NewCachedGitConfig(
-				func(key string) (string, error) {
-					return fake.Get(key), nil
-				},
-				utils.NewDummyLog(),
-			)
-			result := real.GetBool("commit.gpgsign")
-			assert.Equal(t, s.expected, result)
-		})
-	}
-}
-
-func TestGet(t *testing.T) {
-	type scenario struct {
-		testName      string
-		mockResponses map[string]string
-		expected      string
-	}
-
-	scenarios := []scenario{
-		{
-			"not set",
-			map[string]string{},
-			"",
-		},
-		{
-			"is set",
-			map[string]string{"commit.gpgsign": "blah"},
-			"blah",
-		},
-	}
-
-	for _, s := range scenarios {
-		s := s
-		t.Run(s.testName, func(t *testing.T) {
-			fake := NewFakeGitConfig(s.mockResponses)
-			real := NewCachedGitConfig(
-				func(key string) (string, error) {
-					return fake.Get(key), nil
-				},
-				utils.NewDummyLog(),
-			)
-			result := real.Get("commit.gpgsign")
-			assert.Equal(t, s.expected, result)
-		})
-	}
-
-	// verifying that the cache is used
-	count := 0
-	real := NewCachedGitConfig(
-		func(key string) (string, error) {
-			count++
-			assert.Equal(t, "commit.gpgsign", key)
-			return "blah", nil
-		},
-		utils.NewDummyLog(),
-	)
-	result := real.Get("commit.gpgsign")
-	assert.Equal(t, "blah", result)
-	result = real.Get("commit.gpgsign")
-	assert.Equal(t, "blah", result)
-	assert.Equal(t, 1, count)
-}
@@ -1,22 +0,0 @@
-package git_config
-
-type FakeGitConfig struct {
-	mockResponses map[string]string
-}
-
-func NewFakeGitConfig(mockResponses map[string]string) *FakeGitConfig {
-	return &FakeGitConfig{
-		mockResponses: mockResponses,
-	}
-}
-
-func (self *FakeGitConfig) Get(key string) string {
-	if self.mockResponses == nil {
-		return ""
-	}
-	return self.mockResponses[key]
-}
-
-func (self *FakeGitConfig) GetBool(key string) bool {
-	return isTruthy(self.Get(key))
-}
@@ -1,56 +0,0 @@
-package git_config
-
-import (
-	"bytes"
-	"fmt"
-	"io/ioutil"
-	"os/exec"
-	"strings"
-	"syscall"
-
-	"github.com/jesseduffield/lazygit/pkg/secureexec"
-)
-
-// including license from https://github.com/tcnksm/go-gitconfig because this file is an adaptation of that repo's code
-// Copyright (c) 2014 tcnksm
-
-// MIT License
-
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// 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}
-	var stdout bytes.Buffer
-	cmd := secureexec.Command("git", gitArgs...)
-	cmd.Stdout = &stdout
-	cmd.Stderr = ioutil.Discard
-
-	err := cmd.Run()
-	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 "", err
-	}
-
-	return strings.TrimRight(stdout.String(), "\000"), nil
-}
@@ -0,0 +1,9 @@
+package commands
+
+// Conflict : A git conflict with a start middle and end corresponding to line
+// numbers in the file where the conflict bars appear
+type Conflict struct {
+	Start  int
+	Middle int
+	End    int
+}
@@ -52,12 +52,6 @@ func (b *BranchListBuilder) obtainBranches() []*models.Branch {
 		}

 		split := strings.Split(line, SEPARATION_CHAR)
-		if len(split) != 4 {
-			// Ignore line if it isn't separated into 4 parts
-			// This is probably a warning message, for more info see:
-			// https://github.com/jesseduffield/lazygit/issues/1385#issuecomment-885580439
-			continue
-		}

 		name := strings.TrimPrefix(split[1], "heads/")
 		branch := &models.Branch{
@@ -4,37 +4,45 @@ import (
 	"strings"

 	"github.com/jesseduffield/lazygit/pkg/commands/models"
+	"github.com/jesseduffield/lazygit/pkg/commands/patch"
 )

 // GetFilesInDiff get the specified commit files
-func (c *GitCommand) GetFilesInDiff(from string, to string, reverse bool) ([]*models.CommitFile, error) {
+func (c *GitCommand) GetFilesInDiff(from string, to string, reverse bool, patchManager *patch.PatchManager) ([]*models.CommitFile, error) {
 	reverseFlag := ""
 	if reverse {
 		reverseFlag = " -R "
 	}

-	filenames, err := c.RunCommandWithOutput("git diff --submodule --no-ext-diff --name-status -z --no-renames %s %s %s", reverseFlag, from, to)
+	filenames, err := c.OSCommand.RunCommandWithOutput("git diff --submodule --no-ext-diff --name-status %s %s %s", reverseFlag, from, to)
 	if err != nil {
 		return nil, err
 	}

-	return c.getCommitFilesFromFilenames(filenames), nil
+	return c.getCommitFilesFromFilenames(filenames, to, patchManager), nil
 }

 // filenames string is something like "file1\nfile2\nfile3"
-func (c *GitCommand) getCommitFilesFromFilenames(filenames string) []*models.CommitFile {
+func (c *GitCommand) getCommitFilesFromFilenames(filenames string, parent string, patchManager *patch.PatchManager) []*models.CommitFile {
 	commitFiles := make([]*models.CommitFile, 0)

-	lines := strings.Split(strings.TrimRight(filenames, "\x00"), "\x00")
-	n := len(lines)
-	for i := 0; i < n-1; i += 2 {
+	for _, line := range strings.Split(strings.TrimRight(filenames, "\n"), "\n") {
 		// typical result looks like 'A my_file' meaning my_file was added
-		changeStatus := lines[i]
-		name := lines[i+1]
+		if line == "" {
+			continue
+		}
+		changeStatus := line[0:1]
+		name := line[2:]
+		status := patch.UNSELECTED
+		if patchManager != nil && patchManager.To == parent {
+			status = patchManager.GetFileStatus(name)
+		}

 		commitFiles = append(commitFiles, &models.CommitFile{
+			Parent:       parent,
 			Name:         name,
 			ChangeStatus: changeStatus,
+			PatchStatus:  status,
 		})
 	}

@@ -10,9 +10,9 @@ import (
 	"strconv"
 	"strings"

+	"github.com/fatih/color"
 	"github.com/jesseduffield/lazygit/pkg/commands/models"
 	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/jesseduffield/lazygit/pkg/gui/style"
 	"github.com/jesseduffield/lazygit/pkg/i18n"
 	"github.com/sirupsen/logrus"
 )
@@ -37,12 +37,7 @@ type CommitListBuilder struct {
 }

 // NewCommitListBuilder builds a new commit list builder
-func NewCommitListBuilder(
-	log *logrus.Entry,
-	gitCommand *GitCommand,
-	osCommand *oscommands.OSCommand,
-	tr *i18n.TranslationSet,
-) *CommitListBuilder {
+func NewCommitListBuilder(log *logrus.Entry, gitCommand *GitCommand, osCommand *oscommands.OSCommand, tr *i18n.TranslationSet) *CommitListBuilder {
 	return &CommitListBuilder{
 		Log:        log,
 		GitCommand: gitCommand,
@@ -77,6 +72,10 @@ func (c *CommitListBuilder) extractCommitFromLine(line string) *models.Commit {

 	unitTimestampInt, _ := strconv.Atoi(unixTimestamp)

+	// Any commit with multiple parents is a merge commit.
+	// If there's a space then it means there must be more than one parent hash
+	isMerge := strings.Contains(parentHashes, " ")
+
 	return &models.Commit{
 		Sha:           sha,
 		Name:          message,
@@ -84,7 +83,7 @@ func (c *CommitListBuilder) extractCommitFromLine(line string) *models.Commit {
 		ExtraInfo:     extraInfo,
 		UnixTimestamp: int64(unitTimestampInt),
 		Author:        author,
-		Parents:       strings.Split(parentHashes, " "),
+		IsMerge:       isMerge,
 	}
 }

@@ -93,8 +92,6 @@ type GetCommitsOptions struct {
 	FilterPath           string
 	IncludeRebaseCommits bool
 	RefName              string // e.g. "HEAD" or "my_branch"
-	// determines if we show the whole git graph i.e. pass the '--all' flag
-	All bool
 }

 func (c *CommitListBuilder) MergeRebasingCommits(commits []*models.Commit) ([]*models.Commit, error) {
@@ -117,7 +114,7 @@ func (c *CommitListBuilder) MergeRebasingCommits(commits []*models.Commit) ([]*m
 		return result, nil
 	}

-	rebasingCommits, err := c.getHydratedRebasingCommits(rebaseMode)
+	rebasingCommits, err := c.getRebasingCommits(rebaseMode)
 	if err != nil {
 		return nil, err
 	}
@@ -156,7 +153,7 @@ func (c *CommitListBuilder) GetCommits(opts GetCommitsOptions) ([]*models.Commit
 	cmd := c.getLogCmd(opts)

 	err = oscommands.RunLineOutputCmd(cmd, func(line string) (bool, error) {
-		if canExtractCommit(line) {
+		if strings.Split(line, " ")[0] != "gpg:" {
 			commit := c.extractCommitFromLine(line)
 			if commit.Sha == firstPushedCommit {
 				passedFirstPushedCommit = true
@@ -172,7 +169,8 @@ func (c *CommitListBuilder) GetCommits(opts GetCommitsOptions) ([]*models.Commit

 	if rebaseMode != "" {
 		currentCommit := commits[len(rebasingCommits)]
-		youAreHere := style.FgYellow.Sprintf("<-- %s ---", c.Tr.YouAreHere)
+		blue := color.New(color.FgYellow)
+		youAreHere := blue.Sprintf("<-- %s ---", c.Tr.YouAreHere)
 		currentCommit.Name = fmt.Sprintf("%s %s", youAreHere, currentCommit.Name)
 	}

@@ -184,57 +182,12 @@ func (c *CommitListBuilder) GetCommits(opts GetCommitsOptions) ([]*models.Commit
 	return commits, nil
 }

-func (c *CommitListBuilder) getHydratedRebasingCommits(rebaseMode string) ([]*models.Commit, error) {
-	commits, err := c.getRebasingCommits(rebaseMode)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(commits) == 0 {
-		return nil, nil
-	}
-
-	commitShas := make([]string, len(commits))
-	for i, commit := range commits {
-		commitShas[i] = commit.Sha
-	}
-
-	// note that we're not filtering these as we do non-rebasing commits just because
-	// I suspect that will cause some damage
-	cmd := c.OSCommand.ExecutableFromString(
-		fmt.Sprintf(
-			"git show %s --no-patch --oneline %s --abbrev=%d",
-			strings.Join(commitShas, " "),
-			prettyFormat,
-			20,
-		),
-	)
-
-	hydratedCommits := make([]*models.Commit, 0, len(commits))
-	i := 0
-	err = oscommands.RunLineOutputCmd(cmd, func(line string) (bool, error) {
-		if canExtractCommit(line) {
-			commit := c.extractCommitFromLine(line)
-			matchingCommit := commits[i]
-			commit.Action = matchingCommit.Action
-			commit.Status = matchingCommit.Status
-			hydratedCommits = append(hydratedCommits, commit)
-			i++
-		}
-		return false, nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	return hydratedCommits, nil
-}
-
 // getRebasingCommits obtains the commits that we're in the process of rebasing
 func (c *CommitListBuilder) getRebasingCommits(rebaseMode string) ([]*models.Commit, error) {
 	switch rebaseMode {
-	case REBASE_MODE_MERGING:
+	case "normal":
 		return c.getNormalRebasingCommits()
-	case REBASE_MODE_INTERACTIVE:
+	case "interactive":
 		return c.getInteractiveRebasingCommits()
 	default:
 		return nil, nil
@@ -374,7 +327,7 @@ func (c *CommitListBuilder) getMergeBase(refName string) (string, error) {
 	}

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

@@ -391,7 +344,7 @@ func ignoringWarnings(commandOutput string) string {
 // getFirstPushedCommit returns the first commit SHA which has been pushed to the ref's upstream.
 // all commits above this are deemed unpushed and marked as such.
 func (c *CommitListBuilder) getFirstPushedCommit(refName string) (string, error) {
-	output, err := c.OSCommand.RunCommandWithOutput("git merge-base %s %s@{u}", c.OSCommand.Quote(refName), c.OSCommand.Quote(refName))
+	output, err := c.OSCommand.RunCommandWithOutput("git merge-base %s %s@{u}", refName, refName)
 	if err != nil {
 		return "", err
 	}
@@ -411,37 +364,18 @@ func (c *CommitListBuilder) getLogCmd(opts GetCommitsOptions) *exec.Cmd {
 		filterFlag = fmt.Sprintf(" --follow -- %s", c.OSCommand.Quote(opts.FilterPath))
 	}

-	config := c.GitCommand.Config.GetUserConfig().Git.Log
-
-	orderFlag := "--" + config.Order
-	allFlag := ""
-	if opts.All {
-		allFlag = " --all"
-	}
-
 	return c.OSCommand.ExecutableFromString(
 		fmt.Sprintf(
-			"git log %s %s %s --oneline %s %s --abbrev=%d %s",
-			c.OSCommand.Quote(opts.RefName),
-			orderFlag,
-			allFlag,
-			prettyFormat,
+			"git log %s --oneline --pretty=format:\"%%H%s%%at%s%%aN%s%%d%s%%p%s%%s\" %s --abbrev=%d --date=unix %s",
+			opts.RefName,
+			SEPARATION_CHAR,
+			SEPARATION_CHAR,
+			SEPARATION_CHAR,
+			SEPARATION_CHAR,
+			SEPARATION_CHAR,
 			limitFlag,
 			20,
 			filterFlag,
 		),
 	)
 }
-
-var prettyFormat = fmt.Sprintf(
-	"--pretty=format:\"%%H%s%%at%s%%aN%s%%d%s%%p%s%%s\"",
-	SEPARATION_CHAR,
-	SEPARATION_CHAR,
-	SEPARATION_CHAR,
-	SEPARATION_CHAR,
-	SEPARATION_CHAR,
-)
-
-func canExtractCommit(line string) bool {
-	return strings.Split(line, " ")[0] != "gpg:"
-}
@@ -6,7 +6,6 @@ import (

 	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
 	"github.com/jesseduffield/lazygit/pkg/i18n"
-	"github.com/jesseduffield/lazygit/pkg/secureexec"
 	"github.com/jesseduffield/lazygit/pkg/utils"
 	"github.com/stretchr/testify/assert"
 )
@@ -19,7 +18,7 @@ func NewDummyCommitListBuilder() *CommitListBuilder {
 		Log:        utils.NewDummyLog(),
 		GitCommand: NewDummyGitCommandWithOSCommand(osCommand),
 		OSCommand:  osCommand,
-		Tr:         i18n.NewTranslationSet(utils.NewDummyLog(), "auto"),
+		Tr:         i18n.NewTranslationSet(utils.NewDummyLog()),
 	}
 }

@@ -40,10 +39,10 @@ func TestCommitListBuilderGetMergeBase(t *testing.T) {
 				switch args[0] {
 				case "symbolic-ref":
 					assert.EqualValues(t, []string{"symbolic-ref", "--short", "HEAD"}, args)
-					return secureexec.Command("echo", "master")
+					return exec.Command("echo", "master")
 				case "merge-base":
 					assert.EqualValues(t, []string{"merge-base", "HEAD", "master"}, args)
-					return secureexec.Command("test")
+					return exec.Command("test")
 				}
 				return nil
 			},
@@ -60,10 +59,10 @@ func TestCommitListBuilderGetMergeBase(t *testing.T) {
 				switch args[0] {
 				case "symbolic-ref":
 					assert.EqualValues(t, []string{"symbolic-ref", "--short", "HEAD"}, args)
-					return secureexec.Command("echo", "master")
+					return exec.Command("echo", "master")
 				case "merge-base":
 					assert.EqualValues(t, []string{"merge-base", "HEAD", "master"}, args)
-					return secureexec.Command("echo", "blah")
+					return exec.Command("echo", "blah")
 				}
 				return nil
 			},
@@ -80,10 +79,10 @@ func TestCommitListBuilderGetMergeBase(t *testing.T) {
 				switch args[0] {
 				case "symbolic-ref":
 					assert.EqualValues(t, []string{"symbolic-ref", "--short", "HEAD"}, args)
-					return secureexec.Command("echo", "feature/test")
+					return exec.Command("echo", "feature/test")
 				case "merge-base":
 					assert.EqualValues(t, []string{"merge-base", "HEAD", "develop"}, args)
-					return secureexec.Command("echo", "blah")
+					return exec.Command("echo", "blah")
 				}
 				return nil
 			},
@@ -95,7 +94,7 @@ func TestCommitListBuilderGetMergeBase(t *testing.T) {
 		{
 			"bubbles up error if there is one",
 			func(cmd string, args ...string) *exec.Cmd {
-				return secureexec.Command("test")
+				return exec.Command("test")
 			},
 			func(output string, err error) {
 				assert.Error(t, err)
@@ -15,102 +15,97 @@ type GetStatusFileOptions struct {

 func (c *GitCommand) GetStatusFiles(opts GetStatusFileOptions) []*models.File {
 	// check if config wants us ignoring untracked files
-	untrackedFilesSetting := c.GitConfig.Get("status.showUntrackedFiles")
+	untrackedFilesSetting := c.GetConfigValue("status.showUntrackedFiles")

 	if untrackedFilesSetting == "" {
 		untrackedFilesSetting = "all"
 	}
 	untrackedFilesArg := fmt.Sprintf("--untracked-files=%s", untrackedFilesSetting)

-	statuses, err := c.GitStatus(GitStatusOptions{NoRenames: opts.NoRenames, UntrackedFilesArg: untrackedFilesArg})
+	statusOutput, err := c.GitStatus(GitStatusOptions{NoRenames: opts.NoRenames, UntrackedFilesArg: untrackedFilesArg})
 	if err != nil {
 		c.Log.Error(err)
 	}
+	statusStrings := utils.SplitLines(statusOutput)
 	files := []*models.File{}

-	for _, status := range statuses {
-		if strings.HasPrefix(status.StatusString, "warning") {
-			c.Log.Warningf("warning when calling git status: %s", status.StatusString)
+	for _, statusString := range statusStrings {
+		if strings.HasPrefix(statusString, "warning") {
+			c.Log.Warningf("warning when calling git status: %s", statusString)
 			continue
 		}
-		change := status.Change
+		change := statusString[0:2]
 		stagedChange := change[0:1]
-		unstagedChange := change[1:2]
+		unstagedChange := statusString[1:2]
+		filename := c.OSCommand.Unquote(statusString[3:])
 		untracked := utils.IncludesString([]string{"??", "A ", "AM"}, change)
 		hasNoStagedChanges := utils.IncludesString([]string{" ", "U", "?"}, stagedChange)
 		hasMergeConflicts := utils.IncludesString([]string{"DD", "AA", "UU", "AU", "UA", "UD", "DU"}, change)
 		hasInlineMergeConflicts := utils.IncludesString([]string{"UU", "AA"}, change)

 		file := &models.File{
-			Name:                    status.Name,
-			PreviousName:            status.PreviousName,
-			DisplayString:           status.StatusString,
+			Name:                    filename,
+			DisplayString:           statusString,
 			HasStagedChanges:        !hasNoStagedChanges,
 			HasUnstagedChanges:      unstagedChange != " ",
 			Tracked:                 !untracked,
 			Deleted:                 unstagedChange == "D" || stagedChange == "D",
-			Added:                   unstagedChange == "A" || untracked,
 			HasMergeConflicts:       hasMergeConflicts,
 			HasInlineMergeConflicts: hasInlineMergeConflicts,
-			Type:                    c.OSCommand.FileType(status.Name),
+			Type:                    c.OSCommand.FileType(filename),
 			ShortStatus:             change,
 		}
 		files = append(files, file)
 	}
-
 	return files
 }

-// GitStatus returns the file status of the repo
+// GitStatus returns the plaintext short status of the repo
 type GitStatusOptions struct {
 	NoRenames         bool
 	UntrackedFilesArg string
 }

-type FileStatus struct {
-	StatusString string
-	Change       string // ??, MM, AM, ...
-	Name         string
-	PreviousName string
-}
-
-func (c *GitCommand) GitStatus(opts GitStatusOptions) ([]FileStatus, error) {
+func (c *GitCommand) GitStatus(opts GitStatusOptions) (string, error) {
 	noRenamesFlag := ""
 	if opts.NoRenames {
 		noRenamesFlag = "--no-renames"
 	}

-	statusLines, err := c.RunCommandWithOutput("git status %s --porcelain -z %s", opts.UntrackedFilesArg, noRenamesFlag)
-	if err != nil {
-		return []FileStatus{}, err
+	return c.OSCommand.RunCommandWithOutput("git status %s --porcelain %s", opts.UntrackedFilesArg, noRenamesFlag)
+}
+
+// MergeStatusFiles merge status files
+func (c *GitCommand) MergeStatusFiles(oldFiles, newFiles []*models.File, selectedFile *models.File) []*models.File {
+	if len(oldFiles) == 0 {
+		return newFiles
 	}

-	splitLines := strings.Split(statusLines, "\x00")
-	response := []FileStatus{}
+	appendedIndexes := []int{}

-	for i := 0; i < len(splitLines); i++ {
-		original := splitLines[i]
+	// retain position of files we already could see
+	result := []*models.File{}
+	for _, oldFile := range oldFiles {
+		for newIndex, newFile := range newFiles {
+			if utils.IncludesInt(appendedIndexes, newIndex) {
+				continue
+			}
+			// if we just staged B and in doing so created 'A -> B' and we are currently have oldFile: A and newFile: 'A -> B', we want to wait until we come across B so the our cursor isn't jumping anywhere
+			waitForMatchingFile := selectedFile != nil && newFile.IsRename() && !selectedFile.IsRename() && newFile.Matches(selectedFile) && !oldFile.Matches(selectedFile)

-		if len(original) < 3 {
-			continue
+			if oldFile.Matches(newFile) && !waitForMatchingFile {
+				result = append(result, newFile)
+				appendedIndexes = append(appendedIndexes, newIndex)
+			}
 		}
+	}

-		status := FileStatus{
-			StatusString: original,
-			Change:       original[:2],
-			Name:         original[3:],
-			PreviousName: "",
+	// append any new files to the end
+	for index, newFile := range newFiles {
+		if !utils.IncludesInt(appendedIndexes, index) {
+			result = append(result, newFile)
 		}
-
-		if strings.HasPrefix(status.Change, "R") {
-			// if a line starts with 'R' then the next line is the original file.
-			status.PreviousName = strings.TrimSpace(splitLines[i+1])
-			status.StatusString = fmt.Sprintf("%s %s -> %s", status.Change, status.PreviousName, status.Name)
-			i++
-		}
-
-		response = append(response, status)
 	}

-	return response, nil
+	return result
 }
@@ -1,227 +0,0 @@
-package commands
-
-import (
-	"os/exec"
-	"testing"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/models"
-	"github.com/jesseduffield/lazygit/pkg/secureexec"
-	"github.com/stretchr/testify/assert"
-)
-
-// TestGitCommandGetStatusFiles is a function.
-func TestGitCommandGetStatusFiles(t *testing.T) {
-	type scenario struct {
-		testName string
-		command  func(string, ...string) *exec.Cmd
-		test     func([]*models.File)
-	}
-
-	scenarios := []scenario{
-		{
-			"No files found",
-			func(cmd string, args ...string) *exec.Cmd {
-				return secureexec.Command("echo")
-			},
-			func(files []*models.File) {
-				assert.Len(t, files, 0)
-			},
-		},
-		{
-			"Several files found",
-			func(cmd string, args ...string) *exec.Cmd {
-				return secureexec.Command(
-					"printf",
-					`MM file1.txt\0A  file3.txt\0AM file2.txt\0?? file4.txt\0UU file5.txt`,
-				)
-			},
-			func(files []*models.File) {
-				assert.Len(t, files, 5)
-
-				expected := []*models.File{
-					{
-						Name:                    "file1.txt",
-						HasStagedChanges:        true,
-						HasUnstagedChanges:      true,
-						Tracked:                 true,
-						Added:                   false,
-						Deleted:                 false,
-						HasMergeConflicts:       false,
-						HasInlineMergeConflicts: false,
-						DisplayString:           "MM file1.txt",
-						Type:                    "other",
-						ShortStatus:             "MM",
-					},
-					{
-						Name:                    "file3.txt",
-						HasStagedChanges:        true,
-						HasUnstagedChanges:      false,
-						Tracked:                 false,
-						Added:                   true,
-						Deleted:                 false,
-						HasMergeConflicts:       false,
-						HasInlineMergeConflicts: false,
-						DisplayString:           "A  file3.txt",
-						Type:                    "other",
-						ShortStatus:             "A ",
-					},
-					{
-						Name:                    "file2.txt",
-						HasStagedChanges:        true,
-						HasUnstagedChanges:      true,
-						Tracked:                 false,
-						Added:                   true,
-						Deleted:                 false,
-						HasMergeConflicts:       false,
-						HasInlineMergeConflicts: false,
-						DisplayString:           "AM file2.txt",
-						Type:                    "other",
-						ShortStatus:             "AM",
-					},
-					{
-						Name:                    "file4.txt",
-						HasStagedChanges:        false,
-						HasUnstagedChanges:      true,
-						Tracked:                 false,
-						Added:                   true,
-						Deleted:                 false,
-						HasMergeConflicts:       false,
-						HasInlineMergeConflicts: false,
-						DisplayString:           "?? file4.txt",
-						Type:                    "other",
-						ShortStatus:             "??",
-					},
-					{
-						Name:                    "file5.txt",
-						HasStagedChanges:        false,
-						HasUnstagedChanges:      true,
-						Tracked:                 true,
-						Added:                   false,
-						Deleted:                 false,
-						HasMergeConflicts:       true,
-						HasInlineMergeConflicts: true,
-						DisplayString:           "UU file5.txt",
-						Type:                    "other",
-						ShortStatus:             "UU",
-					},
-				}
-
-				assert.EqualValues(t, expected, files)
-			},
-		},
-		{
-			"File with new line char",
-			func(cmd string, args ...string) *exec.Cmd {
-				return secureexec.Command(
-					"printf",
-					`MM a\nb.txt`,
-				)
-			},
-			func(files []*models.File) {
-				assert.Len(t, files, 1)
-
-				expected := []*models.File{
-					{
-						Name:                    "a\nb.txt",
-						HasStagedChanges:        true,
-						HasUnstagedChanges:      true,
-						Tracked:                 true,
-						Added:                   false,
-						Deleted:                 false,
-						HasMergeConflicts:       false,
-						HasInlineMergeConflicts: false,
-						DisplayString:           "MM a\nb.txt",
-						Type:                    "other",
-						ShortStatus:             "MM",
-					},
-				}
-
-				assert.EqualValues(t, expected, files)
-			},
-		},
-		{
-			"Renamed files",
-			func(cmd string, args ...string) *exec.Cmd {
-				return secureexec.Command(
-					"printf",
-					`R  after1.txt\0before1.txt\0RM after2.txt\0before2.txt`,
-				)
-			},
-			func(files []*models.File) {
-				assert.Len(t, files, 2)
-
-				expected := []*models.File{
-					{
-						Name:                    "after1.txt",
-						PreviousName:            "before1.txt",
-						HasStagedChanges:        true,
-						HasUnstagedChanges:      false,
-						Tracked:                 true,
-						Added:                   false,
-						Deleted:                 false,
-						HasMergeConflicts:       false,
-						HasInlineMergeConflicts: false,
-						DisplayString:           "R  before1.txt -> after1.txt",
-						Type:                    "other",
-						ShortStatus:             "R ",
-					},
-					{
-						Name:                    "after2.txt",
-						PreviousName:            "before2.txt",
-						HasStagedChanges:        true,
-						HasUnstagedChanges:      true,
-						Tracked:                 true,
-						Added:                   false,
-						Deleted:                 false,
-						HasMergeConflicts:       false,
-						HasInlineMergeConflicts: false,
-						DisplayString:           "RM before2.txt -> after2.txt",
-						Type:                    "other",
-						ShortStatus:             "RM",
-					},
-				}
-
-				assert.EqualValues(t, expected, files)
-			},
-		},
-		{
-			"File with arrow in name",
-			func(cmd string, args ...string) *exec.Cmd {
-				return secureexec.Command(
-					"printf",
-					`?? a -> b.txt`,
-				)
-			},
-			func(files []*models.File) {
-				assert.Len(t, files, 1)
-
-				expected := []*models.File{
-					{
-						Name:                    "a -> b.txt",
-						HasStagedChanges:        false,
-						HasUnstagedChanges:      true,
-						Tracked:                 false,
-						Added:                   true,
-						Deleted:                 false,
-						HasMergeConflicts:       false,
-						HasInlineMergeConflicts: false,
-						DisplayString:           "?? a -> b.txt",
-						Type:                    "other",
-						ShortStatus:             "??",
-					},
-				}
-
-				assert.EqualValues(t, expected, files)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommand()
-			gitCmd.OSCommand.Command = s.command
-
-			s.test(gitCmd.GetStatusFiles(GetStatusFileOptions{}))
-		})
-	}
-}
@@ -2,8 +2,8 @@ package commands

 import (
 	"fmt"
+	"regexp"
 	"strconv"
-	"strings"

 	"github.com/jesseduffield/lazygit/pkg/commands/models"
 	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
@@ -13,25 +13,26 @@ import (
 // if none is passed (i.e. it's value is nil) then we get all the reflog commits
 func (c *GitCommand) GetReflogCommits(lastReflogCommit *models.Commit, filterPath string) ([]*models.Commit, bool, error) {
 	commits := make([]*models.Commit, 0)
+	re := regexp.MustCompile(`(\w+).*HEAD@\{([^\}]+)\}: (.*)`)

 	filterPathArg := ""
 	if filterPath != "" {
 		filterPathArg = fmt.Sprintf(" --follow -- %s", c.OSCommand.Quote(filterPath))
 	}

-	cmd := c.OSCommand.ExecutableFromString(fmt.Sprintf(`git log -g --abbrev=20 --format="%%h %%ct %%gs" %s`, filterPathArg))
+	cmd := c.OSCommand.ExecutableFromString(fmt.Sprintf("git reflog --abbrev=20 --date=unix %s", filterPathArg))
 	onlyObtainedNewReflogCommits := false
 	err := oscommands.RunLineOutputCmd(cmd, func(line string) (bool, error) {
-		fields := strings.SplitN(line, " ", 3)
-		if len(fields) <= 2 {
+		match := re.FindStringSubmatch(line)
+		if len(match) <= 1 {
 			return false, nil
 		}

-		unixTimestamp, _ := strconv.Atoi(fields[1])
+		unixTimestamp, _ := strconv.Atoi(match[2])

 		commit := &models.Commit{
-			Sha:           fields[0],
-			Name:          fields[2],
+			Sha:           match[1],
+			Name:          match[3],
 			UnixTimestamp: int64(unixTimestamp),
 			Status:        "reflog",
 		}
@@ -1,6 +1,7 @@
 package commands

 import (
+	"fmt"
 	"regexp"
 	"strconv"
 	"strings"
@@ -25,7 +26,8 @@ func (c *GitCommand) GetStashEntries(filterPath string) []*models.StashEntry {
 		return c.getUnfilteredStashEntries()
 	}

-	rawString, err := c.RunCommandWithOutput("git stash list --name-only")
+	unescaped := fmt.Sprintf("git stash list --name-only")
+	rawString, err := c.OSCommand.RunCommandWithOutput(unescaped)
 	if err != nil {
 		return c.getUnfilteredStashEntries()
 	}
@@ -1,61 +0,0 @@
-package commands
-
-import (
-	"os/exec"
-	"testing"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/models"
-	"github.com/jesseduffield/lazygit/pkg/secureexec"
-	"github.com/stretchr/testify/assert"
-)
-
-// TestGitCommandGetStashEntries is a function.
-func TestGitCommandGetStashEntries(t *testing.T) {
-	type scenario struct {
-		testName string
-		command  func(string, ...string) *exec.Cmd
-		test     func([]*models.StashEntry)
-	}
-
-	scenarios := []scenario{
-		{
-			"No stash entries found",
-			func(string, ...string) *exec.Cmd {
-				return secureexec.Command("echo")
-			},
-			func(entries []*models.StashEntry) {
-				assert.Len(t, entries, 0)
-			},
-		},
-		{
-			"Several stash entries found",
-			func(string, ...string) *exec.Cmd {
-				return secureexec.Command("echo", "WIP on add-pkg-commands-test: 55c6af2 increase parallel build\nWIP on master: bb86a3f update github template")
-			},
-			func(entries []*models.StashEntry) {
-				expected := []*models.StashEntry{
-					{
-						Index: 0,
-						Name:  "WIP on add-pkg-commands-test: 55c6af2 increase parallel build",
-					},
-					{
-						Index: 1,
-						Name:  "WIP on master: bb86a3f update github template",
-					},
-				}
-
-				assert.Len(t, entries, 2)
-				assert.EqualValues(t, expected, entries)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommand()
-			gitCmd.OSCommand.Command = s.command
-
-			s.test(gitCmd.GetStashEntries(""))
-		})
-	}
-}
@@ -1,16 +1,28 @@
 package commands

 import (
+	"regexp"
+	"sort"
+	"strconv"
 	"strings"

 	"github.com/jesseduffield/lazygit/pkg/commands/models"
 	"github.com/jesseduffield/lazygit/pkg/utils"
 )

+const semverRegex = `v?((\d+\.?)+)([^\d]?.*)`
+
+func convertToInt(s string) int {
+	i, err := strconv.Atoi(s)
+	if err != nil {
+		return 0
+	}
+	return i
+}
+
 func (c *GitCommand) 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 := c.OSCommand.RunCommandWithOutput(`git tag --list --sort=-creatordate`)
+	// get remote branches
+	remoteBranchesStr, err := c.OSCommand.RunCommandWithOutput(`git tag --list`)
 	if err != nil {
 		return nil, err
 	}
@@ -25,10 +37,52 @@ func (c *GitCommand) GetTags() ([]*models.Tag, error) {
 	// first step is to get our remotes from go-git
 	tags := make([]*models.Tag, len(split))
 	for i, tagName := range split {
+
 		tags[i] = &models.Tag{
 			Name: tagName,
 		}
 	}

+	// now lets sort our tags by name numerically
+	re := regexp.MustCompile(semverRegex)
+
+	// the reason  this is complicated is because we're both sorting alphabetically
+	// and when we're dealing with semver strings
+	sort.Slice(tags, func(i, j int) bool {
+		a := tags[i].Name
+		b := tags[j].Name
+
+		matchA := re.FindStringSubmatch(a)
+		matchB := re.FindStringSubmatch(b)
+
+		if len(matchA) > 0 && len(matchB) > 0 {
+			numbersA := strings.Split(matchA[1], ".")
+			numbersB := strings.Split(matchB[1], ".")
+			k := 0
+			for {
+				if len(numbersA) == k && len(numbersB) == k {
+					break
+				}
+				if len(numbersA) == k {
+					return true
+				}
+				if len(numbersB) == k {
+					return false
+				}
+				if convertToInt(numbersA[k]) < convertToInt(numbersB[k]) {
+					return true
+				}
+				if convertToInt(numbersA[k]) > convertToInt(numbersB[k]) {
+					return false
+				}
+				k++
+			}
+
+			return strings.ToLower(matchA[3]) < strings.ToLower(matchB[3])
+		}
+
+		return strings.ToLower(a) < strings.ToLower(b)
+	})
+
 	return tags, nil
 }
@@ -24,26 +24,3 @@ func (b *Branch) ID() string {
 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 != "?"
-}
-
-func (b *Branch) MatchesUpstream() bool {
-	return b.IsRealBranch() && b.Pushables == "0" && b.Pullables == "0"
-}
-
-func (b *Branch) HasCommitsToPush() bool {
-	return b.IsRealBranch() && b.Pushables != "0"
-}
-
-func (b *Branch) HasCommitsToPull() bool {
-	return b.IsRealBranch() && b.Pullables != "0"
-}
-
-// for when we're in a detached head state
-func (b *Branch) IsRealBranch() bool {
-	return b.Pushables != "" && b.Pullables != ""
-}
@@ -13,8 +13,8 @@ type Commit struct {
 	Author        string
 	UnixTimestamp int64

-	// SHAs of parent commits (will be multiple if it's a merge commit)
-	Parents []string
+	// IsMerge tells us whether we're dealing with a merge commit i.e. a commit with two parents
+	IsMerge bool
 }

 func (c *Commit) ShortSha() string {
@@ -35,7 +35,3 @@ func (c *Commit) ID() string {
 func (c *Commit) Description() string {
 	return fmt.Sprintf("%s %s", c.Sha[:7], c.Name)
 }
-
-func (c *Commit) IsMerge() bool {
-	return len(c.Parents) > 1
-}
@@ -2,8 +2,12 @@ package models

 // CommitFile : A git commit file
 type CommitFile struct {
-	// TODO: rename this to Path
-	Name string
+	// Parent is the identifier of the parent object e.g. a commit SHA if this commit file is for a commit, or a stash entry ref like 'stash@{1}'
+	Parent string
+	Name   string
+
+	// PatchStatus tells us whether the file has been wholly or partially added to a patch. We might want to pull this logic up into the gui package and make it a map like we do with cherry picked commits
+	PatchStatus int // one of 'WHOLE' 'PART' 'NONE'

 	ChangeStatus string // e.g. 'A' for added or 'M' for modified. This is based on the result from git diff --name-status
 }
@@ -1,6 +1,8 @@
 package models

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

@@ -8,11 +10,9 @@ import (
 // duplicating this for now
 type File struct {
 	Name                    string
-	PreviousName            string
 	HasStagedChanges        bool
 	HasUnstagedChanges      bool
 	Tracked                 bool
-	Added                   bool
 	Deleted                 bool
 	HasMergeConflicts       bool
 	HasInlineMergeConflicts bool
@@ -21,25 +21,15 @@ type File struct {
 	ShortStatus             string // e.g. 'AD', ' A', 'M ', '??'
 }

-// sometimes we need to deal with either a node (which contains a file) or an actual file
-type IFile interface {
-	GetHasUnstagedChanges() bool
-	GetHasStagedChanges() bool
-	GetIsTracked() bool
-	GetPath() string
-}
+const RENAME_SEPARATOR = " -> "

 func (f *File) IsRename() bool {
-	return f.PreviousName != ""
+	return strings.Contains(f.Name, RENAME_SEPARATOR)
 }

 // Names returns an array containing just the filename, or in the case of a rename, the after filename and the before filename
 func (f *File) Names() []string {
-	result := []string{f.Name}
-	if f.PreviousName != "" {
-		result = append(result, f.PreviousName)
-	}
-	return result
+	return strings.Split(f.Name, RENAME_SEPARATOR)
 }

 // returns true if the file names are the same or if a a file rename includes the filename of the other
@@ -61,27 +51,10 @@ func (f *File) IsSubmodule(configs []*SubmoduleConfig) bool {

 func (f *File) SubmoduleConfig(configs []*SubmoduleConfig) *SubmoduleConfig {
 	for _, config := range configs {
-		if f.Name == config.Path {
+		if f.Name == config.Name {
 			return config
 		}
 	}

 	return nil
 }
-
-func (f *File) GetHasUnstagedChanges() bool {
-	return f.HasUnstagedChanges
-}
-
-func (f *File) GetHasStagedChanges() bool {
-	return f.HasStagedChanges
-}
-
-func (f *File) GetIsTracked() bool {
-	return f.Tracked
-}
-
-func (f *File) GetPath() string {
-	// TODO: remove concept of name; just use path
-	return f.Name
-}
@@ -1,33 +0,0 @@
-package oscommands
-
-import (
-	"os/exec"
-)
-
-// A command object is a general way to represent a command to be run on the
-// command line. If you want to log the command you'll use .ToString() and
-// if you want to run it you'll use .GetCmd()
-type ICmdObj interface {
-	GetCmd() *exec.Cmd
-	ToString() string
-	AddEnvVars(...string) ICmdObj
-}
-
-type CmdObj struct {
-	cmdStr string
-	cmd    *exec.Cmd
-}
-
-func (self *CmdObj) GetCmd() *exec.Cmd {
-	return self.cmd
-}
-
-func (self *CmdObj) ToString() string {
-	return self.cmdStr
-}
-
-func (self *CmdObj) AddEnvVars(vars ...string) ICmdObj {
-	self.cmd.Env = append(self.cmd.Env, vars...)
-
-	return self
-}
@@ -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
-}
@@ -1,37 +1,97 @@
-//go:build !windows
 // +build !windows

 package oscommands

 import (
-	"io"
-	"os/exec"
+	"bufio"
+	"bytes"
+	"strings"
+	"unicode/utf8"
+
+	"github.com/go-errors/errors"
+	"github.com/jesseduffield/lazygit/pkg/utils"

 	"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
-			}
+// RunCommandWithOutputLiveWrapper 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 written anything to stdin
+func RunCommandWithOutputLiveWrapper(c *OSCommand, command string, output func(string) string) error {
+	c.Log.WithField("command", command).Info("RunCommand")
+	cmd := c.ExecutableFromString(command)
+	cmd.Env = append(cmd.Env, "LANG=en_US.UTF-8", "LC_ALL=en_US.UTF-8")

-			return &cmdHandler{
-				stdoutPipe: ptmx,
-				stdinPipe:  ptmx,
-				close:      ptmx.Close,
-			}, nil
-		},
-	)
+	var stderr bytes.Buffer
+	cmd.Stderr = &stderr
+
+	ptmx, err := pty.Start(cmd)
+
+	if err != nil {
+		return err
+	}
+
+	go utils.Safe(func() {
+		scanner := bufio.NewScanner(ptmx)
+		scanner.Split(scanWordsWithNewLines)
+		for scanner.Scan() {
+			toOutput := strings.Trim(scanner.Text(), " ")
+			_, _ = ptmx.WriteString(output(toOutput))
+		}
+	})
+
+	err = cmd.Wait()
+	ptmx.Close()
+	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
 }
@@ -1,63 +1,9 @@
-//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
-		},
-	)
+// TODO: Remove this hack and replace it with a proper way to run commands live on windows
+func RunCommandWithOutputLiveWrapper(c *OSCommand, command string, output func(string) string) error {
+	return c.RunCommand(command)
 }
@@ -7,6 +7,8 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"regexp"
+	"strconv"
 	"strings"
 	"sync"

@@ -14,123 +16,54 @@ import (

 	"github.com/atotto/clipboard"
 	"github.com/jesseduffield/lazygit/pkg/config"
-	"github.com/jesseduffield/lazygit/pkg/secureexec"
 	"github.com/jesseduffield/lazygit/pkg/utils"
 	"github.com/mgutz/str"
 	"github.com/sirupsen/logrus"
+	gitconfig "github.com/tcnksm/go-gitconfig"
 )

 // Platform stores the os state
 type Platform struct {
-	OS              string
-	Shell           string
-	ShellArg        string
-	OpenCommand     string
-	OpenLinkCommand string
+	OS                   string
+	CatCmd               string
+	Shell                string
+	ShellArg             string
+	EscapedQuote         string
+	OpenCommand          string
+	OpenLinkCommand      string
+	FallbackEscapedQuote string
 }

 // OSCommand holds all the os commands
 type OSCommand struct {
-	Log              *logrus.Entry
-	Platform         *Platform
-	Config           config.AppConfigurer
-	Command          func(string, ...string) *exec.Cmd
-	BeforeExecuteCmd func(*exec.Cmd)
-	Getenv           func(string) string
-
-	// 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
-}
-
-// 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}
+	Log                *logrus.Entry
+	Platform           *Platform
+	Config             config.AppConfigurer
+	Command            func(string, ...string) *exec.Cmd
+	BeforeExecuteCmd   func(*exec.Cmd)
+	GetGlobalGitConfig func(string) (string, error)
+	Getenv             func(string) string
 }

 // NewOSCommand os command runner
 func NewOSCommand(log *logrus.Entry, config config.AppConfigurer) *OSCommand {
 	return &OSCommand{
-		Log:              log,
-		Platform:         getPlatform(),
-		Config:           config,
-		Command:          secureexec.Command,
-		BeforeExecuteCmd: func(*exec.Cmd) {},
-		Getenv:           os.Getenv,
-		removeFile:       os.RemoveAll,
+		Log:                log,
+		Platform:           getPlatform(),
+		Config:             config,
+		Command:            exec.Command,
+		BeforeExecuteCmd:   func(*exec.Cmd) {},
+		GetGlobalGitConfig: gitconfig.Global,
+		Getenv:             os.Getenv,
 	}
 }

-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
-	return newOSCommand
-}
-
-func (c *OSCommand) LogExecCmd(cmd *exec.Cmd) {
-	c.LogCommand(strings.Join(cmd.Args, " "), 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
-}
-
 // SetCommand sets the command function used by the struct.
 // To be used for testing only
 func (c *OSCommand) SetCommand(cmd func(string, ...string) *exec.Cmd) {
 	c.Command = cmd
 }

-// To be used for testing only
-func (c *OSCommand) SetRemoveFile(f func(string) error) {
-	c.removeFile = f
-}
-
 func (c *OSCommand) SetBeforeExecuteCmd(cmd func(*exec.Cmd)) {
 	c.BeforeExecuteCmd = cmd
 }
@@ -140,12 +73,9 @@ type RunCommandOptions struct {
 }

 func (c *OSCommand) RunCommandWithOutputWithOptions(command string, options RunCommandOptions) (string, error) {
-	c.LogCommand(command, true)
+	c.Log.WithField("command", command).Info("RunCommand")
 	cmd := c.ExecutableFromString(command)
-
-	cmd.Env = append(cmd.Env, "GIT_TERMINAL_PROMPT=0") // prevents git from prompting us for input which would freeze the program
 	cmd.Env = append(cmd.Env, options.EnvVars...)
-
 	return sanitisedCommandOutput(cmd.CombinedOutput())
 }

@@ -165,18 +95,17 @@ func (c *OSCommand) RunCommandWithOutput(formatString string, formatArgs ...inte
 	if formatArgs != nil {
 		command = fmt.Sprintf(formatString, formatArgs...)
 	}
+	c.Log.WithField("command", command).Info("RunCommand")
 	cmd := c.ExecutableFromString(command)
-	c.LogExecCmd(cmd)
 	output, err := sanitisedCommandOutput(cmd.CombinedOutput())
 	if err != nil {
-		c.Log.WithField("command", command).Error(output)
+		c.Log.WithField("command", command).Error(err)
 	}
 	return output, err
 }

 // RunExecutableWithOutput runs an executable file and returns its output
 func (c *OSCommand) RunExecutableWithOutput(cmd *exec.Cmd) (string, error) {
-	c.LogExecCmd(cmd)
 	c.BeforeExecuteCmd(cmd)
 	return sanitisedCommandOutput(cmd.CombinedOutput())
 }
@@ -200,39 +129,53 @@ func (c *OSCommand) ShellCommandFromString(commandStr string) *exec.Cmd {
 	quotedCommand := ""
 	// Windows does not seem to like quotes around the command
 	if c.Platform.OS == "windows" {
-		quotedCommand = strings.NewReplacer(
-			"^", "^^",
-			"&", "^&",
-			"|", "^|",
-			"<", "^<",
-			">", "^>",
-			"%", "^%",
-		).Replace(commandStr)
+		quotedCommand = commandStr
 	} else {
-		quotedCommand = c.Quote(commandStr)
+		quotedCommand = strconv.Quote(commandStr)
 	}

 	shellCommand := fmt.Sprintf("%s %s %s", c.Platform.Shell, c.Platform.ShellArg, quotedCommand)
 	return c.ExecutableFromString(shellCommand)
 }

+// RunCommandWithOutputLive runs RunCommandWithOutputLiveWrapper
+func (c *OSCommand) RunCommandWithOutputLive(command string, output func(string) string) error {
+	return RunCommandWithOutputLiveWrapper(c, command, output)
+}
+
+// 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(command string, promptUserForCredential func(string) string) error {
+	ttyText := ""
+	errMessage := c.RunCommandWithOutputLive(command, 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
+}
+
 // RunCommand runs a command and just returns the error
 func (c *OSCommand) RunCommand(formatString string, formatArgs ...interface{}) error {
 	_, err := c.RunCommandWithOutput(formatString, formatArgs...)
 	return err
 }

-// RunShellCommand runs shell commands i.e. 'sh -c <command>'. Good for when you
-// need access to the shell
-func (c *OSCommand) RunShellCommand(command string) error {
-	cmd := c.ShellCommandFromString(command)
-	c.LogExecCmd(cmd)
-
-	_, err := sanitisedCommandOutput(cmd.CombinedOutput())
-
-	return err
-}
-
 // FileType tells us if the file is a file, directory or other
 func (c *OSCommand) FileType(path string) string {
 	fileInfo, err := os.Stat(path)
@@ -245,6 +188,16 @@ func (c *OSCommand) FileType(path string) string {
 	return "file"
 }

+// RunDirectCommand wrapper around direct commands
+func (c *OSCommand) RunDirectCommand(command string) (string, error) {
+	c.Log.WithField("command", command).Info("RunDirectCommand")
+
+	return sanitisedCommandOutput(
+		c.Command(c.Platform.Shell, c.Platform.ShellArg, command).
+			CombinedOutput(),
+	)
+}
+
 func sanitisedCommandOutput(output []byte, err error) (string, error) {
 	outputString := string(output)
 	if err != nil {
@@ -264,24 +217,49 @@ func (c *OSCommand) OpenFile(filename string) error {
 	templateValues := map[string]string{
 		"filename": c.Quote(filename),
 	}
+
 	command := utils.ResolvePlaceholderString(commandTemplate, templateValues)
-	err := c.RunShellCommand(command)
+	err := c.RunCommand(command)
 	return err
 }

 // 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.Config.GetUserConfig().OS.OpenLinkCommand
 	templateValues := map[string]string{
 		"link": c.Quote(link),
 	}

 	command := utils.ResolvePlaceholderString(commandTemplate, templateValues)
-	err := c.RunShellCommand(command)
+	err := c.RunCommand(command)
 	return err
 }

+// EditFile opens a file in a subprocess using whatever editor is available,
+// falling back to core.editor, VISUAL, EDITOR, then vi
+func (c *OSCommand) EditFile(filename string) (*exec.Cmd, error) {
+	editor, _ := c.GetGlobalGitConfig("core.editor")
+
+	if editor == "" {
+		editor = c.Getenv("VISUAL")
+	}
+	if editor == "" {
+		editor = c.Getenv("EDITOR")
+	}
+	if editor == "" {
+		if err := c.RunCommand("which vi"); err == nil {
+			editor = "vi"
+		}
+	}
+	if editor == "" {
+		return nil, errors.New("No editor defined in $VISUAL, $EDITOR, or git config")
+	}
+
+	splitCmd := str.ToArgv(fmt.Sprintf("%s %s", editor, c.Quote(filename)))
+
+	return c.PrepareSubProcess(splitCmd[0], splitCmd[1:]...), nil
+}
+
 // PrepareSubProcess iniPrepareSubProcessrocess then tells the Gui to switch to it
 // TODO: see if this needs to exist, given that ExecutableFromString does the same things
 func (c *OSCommand) PrepareSubProcess(cmdName string, commandArgs ...string) *exec.Cmd {
@@ -289,39 +267,27 @@ func (c *OSCommand) PrepareSubProcess(cmdName string, commandArgs ...string) *ex
 	if cmd != nil {
 		cmd.Env = append(os.Environ(), "GIT_OPTIONAL_LOCKS=0")
 	}
-	c.LogExecCmd(cmd)
 	return cmd
 }

-// PrepareShellSubProcess returns the pointer to a custom command
-func (c *OSCommand) PrepareShellSubProcess(command string) *exec.Cmd {
-	return c.PrepareSubProcess(c.Platform.Shell, c.Platform.ShellArg, command)
-}
-
 // Quote wraps a message in platform-specific quotation marks
 func (c *OSCommand) Quote(message string) string {
-	var quote string
-	if c.Platform.OS == "windows" {
-		quote = `\"`
-		message = strings.NewReplacer(
-			`"`, `"'"'"`,
-			`\"`, `\\"`,
-		).Replace(message)
-	} else {
-		quote = `"`
-		message = strings.NewReplacer(
-			`\`, `\\`,
-			`"`, `\"`,
-			`$`, `\$`,
-			"`", "\\`",
-		).Replace(message)
+	message = strings.Replace(message, "`", "\\`", -1)
+	escapedQuote := c.Platform.EscapedQuote
+	if strings.Contains(message, c.Platform.EscapedQuote) {
+		escapedQuote = c.Platform.FallbackEscapedQuote
 	}
-	return quote + message + quote
+	return escapedQuote + message + escapedQuote
+}
+
+// Unquote removes wrapping quotations marks if they are present
+// this is needed for removing quotes from staged filenames with spaces
+func (c *OSCommand) Unquote(message string) string {
+	return strings.Replace(message, `"`, "", -1)
 }

 // 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)
 	f, err := os.OpenFile(filename, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0600)
 	if err != nil {
 		return utils.WrapError(err)
@@ -342,7 +308,6 @@ func (c *OSCommand) CreateTempFile(filename, content string) (string, error) {
 		c.Log.Error(err)
 		return "", utils.WrapError(err)
 	}
-	c.LogCommand(fmt.Sprintf("Creating temp file '%s'", tmpfile.Name()), false)

 	if _, err := tmpfile.WriteString(content); err != nil {
 		c.Log.Error(err)
@@ -358,7 +323,6 @@ func (c *OSCommand) CreateTempFile(filename, content string) (string, error) {

 // CreateFileWithContent creates a file with the given content
 func (c *OSCommand) CreateFileWithContent(path string, content string) error {
-	c.LogCommand(fmt.Sprintf("Creating file '%s'", path), false)
 	if err := os.MkdirAll(filepath.Dir(path), os.ModePerm); err != nil {
 		c.Log.Error(err)
 		return err
@@ -374,7 +338,6 @@ func (c *OSCommand) CreateFileWithContent(path string, content string) error {

 // Remove removes a file or directory at the specified path
 func (c *OSCommand) Remove(filename string) error {
-	c.LogCommand(fmt.Sprintf("Removing '%s'", filename), false)
 	err := os.RemoveAll(filename)
 	return utils.WrapError(err)
 }
@@ -395,7 +358,6 @@ func (c *OSCommand) FileExists(path string) (bool, error) {
 // before running it
 func (c *OSCommand) RunPreparedCommand(cmd *exec.Cmd) error {
 	c.BeforeExecuteCmd(cmd)
-	c.LogExecCmd(cmd)
 	out, err := cmd.CombinedOutput()
 	outString := string(out)
 	c.Log.Info(outString)
@@ -417,18 +379,19 @@ func (c *OSCommand) GetLazygitPath() string {
 	return `"` + filepath.ToSlash(ex) + `"`
 }

+// RunCustomCommand returns the pointer to a custom command
+func (c *OSCommand) RunCustomCommand(command string) *exec.Cmd {
+	return c.PrepareSubProcess(c.Platform.Shell, c.Platform.ShellArg, command)
+}
+
 // 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))
-	logCmdStr := ""
+
 	for i, str := range commandStrings {
-		if i > 0 {
-			logCmdStr += " | "
-		}
-		logCmdStr += str
 		cmds[i] = c.ExecutableFromString(str)
 	}
-	c.LogCommand(logCmdStr, true)

 	for i := 0; i < len(cmds)-1; i++ {
 		stdout, err := cmds[i].StdoutPipe()
@@ -508,52 +471,15 @@ func RunLineOutputCmd(cmd *exec.Cmd, onLine func(line string) (bool, error)) err
 			return err
 		}
 		if stop {
-			_ = cmd.Process.Kill()
+			cmd.Process.Kill()
 			break
 		}
 	}

-	_ = cmd.Wait()
-
+	cmd.Wait()
 	return nil
 }

 func (c *OSCommand) CopyToClipboard(str string) error {
-	escaped := strings.Replace(str, "\n", "\\n", -1)
-	truncated := utils.TruncateWithEllipsis(escaped, 40)
-	c.LogCommand(fmt.Sprintf("Copying '%s' to clipboard", truncated), false)
 	return clipboard.WriteAll(str)
 }
-
-func (c *OSCommand) RemoveFile(path string) error {
-	c.LogCommand(fmt.Sprintf("Deleting path '%s'", path), false)
-
-	return c.removeFile(path)
-}
-
-func (c *OSCommand) NewCmdObjFromStr(cmdStr string) ICmdObj {
-	args := str.ToArgv(cmdStr)
-	cmd := c.Command(args[0], args[1:]...)
-	cmd.Env = os.Environ()
-
-	return &CmdObj{
-		cmdStr: cmdStr,
-		cmd:    cmd,
-	}
-}
-
-func (c *OSCommand) NewCmdObjFromArgs(args []string) ICmdObj {
-	cmd := c.Command(args[0], args[1:]...)
-
-	return &CmdObj{
-		cmdStr: strings.Join(args, " "),
-		cmd:    cmd,
-	}
-}
-
-func (c *OSCommand) NewCmdObj(cmd *exec.Cmd) ICmdObj {
-	return &CmdObj{
-		cmdStr: strings.Join(cmd.Args, " "),
-		cmd:    cmd,
-	}
-}
@@ -1,4 +1,3 @@
-//go:build !windows
 // +build !windows

 package oscommands
@@ -9,10 +8,13 @@ import (

 func getPlatform() *Platform {
 	return &Platform{
-		OS:              runtime.GOOS,
-		Shell:           "bash",
-		ShellArg:        "-c",
-		OpenCommand:     "open {{filename}}",
-		OpenLinkCommand: "open {{link}}",
+		OS:                   runtime.GOOS,
+		CatCmd:               "cat",
+		Shell:                "bash",
+		ShellArg:             "-c",
+		EscapedQuote:         "'",
+		OpenCommand:          "open {{filename}}",
+		OpenLinkCommand:      "open {{link}}",
+		FallbackEscapedQuote: "\"",
 	}
 }
@@ -1,138 +0,0 @@
-//go:build !windows
-// +build !windows
-
-package oscommands
-
-import (
-	"os/exec"
-	"testing"
-
-	"github.com/jesseduffield/lazygit/pkg/secureexec"
-	"github.com/stretchr/testify/assert"
-)
-
-// TestOSCommandOpenFileDarwin is a function.
-func TestOSCommandOpenFileDarwin(t *testing.T) {
-	type scenario struct {
-		filename string
-		command  func(string, ...string) *exec.Cmd
-		test     func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			"test",
-			func(name string, arg ...string) *exec.Cmd {
-				return secureexec.Command("exit", "1")
-			},
-			func(err error) {
-				assert.Error(t, err)
-			},
-		},
-		{
-			"test",
-			func(name string, arg ...string) *exec.Cmd {
-				assert.Equal(t, "bash", name)
-				assert.Equal(t, []string{"-c", `open "test"`}, arg)
-				return secureexec.Command("echo")
-			},
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			"filename with spaces",
-			func(name string, arg ...string) *exec.Cmd {
-				assert.Equal(t, "bash", name)
-				assert.Equal(t, []string{"-c", `open "filename with spaces"`}, arg)
-				return secureexec.Command("echo")
-			},
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		OSCmd := NewDummyOSCommand()
-		OSCmd.Platform.OS = "darwin"
-		OSCmd.Command = s.command
-		OSCmd.Config.GetUserConfig().OS.OpenCommand = "open {{filename}}"
-
-		s.test(OSCmd.OpenFile(s.filename))
-	}
-}
-
-// TestOSCommandOpenFileLinux tests the OpenFile command on Linux
-func TestOSCommandOpenFileLinux(t *testing.T) {
-	type scenario struct {
-		filename string
-		command  func(string, ...string) *exec.Cmd
-		test     func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			"test",
-			func(name string, arg ...string) *exec.Cmd {
-				return secureexec.Command("exit", "1")
-			},
-			func(err error) {
-				assert.Error(t, err)
-			},
-		},
-		{
-			"test",
-			func(name string, arg ...string) *exec.Cmd {
-				assert.Equal(t, "bash", name)
-				assert.Equal(t, []string{"-c", `xdg-open "test" > /dev/null`}, arg)
-				return secureexec.Command("echo")
-			},
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			"filename with spaces",
-			func(name string, arg ...string) *exec.Cmd {
-				assert.Equal(t, "bash", name)
-				assert.Equal(t, []string{"-c", `xdg-open "filename with spaces" > /dev/null`}, arg)
-				return secureexec.Command("echo")
-			},
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			"let's_test_with_single_quote",
-			func(name string, arg ...string) *exec.Cmd {
-				assert.Equal(t, "bash", name)
-				assert.Equal(t, []string{"-c", `xdg-open "let's_test_with_single_quote" > /dev/null`}, arg)
-				return secureexec.Command("echo")
-			},
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			"$USER.txt",
-			func(name string, arg ...string) *exec.Cmd {
-				assert.Equal(t, "bash", name)
-				assert.Equal(t, []string{"-c", `xdg-open "\$USER.txt" > /dev/null`}, arg)
-				return secureexec.Command("echo")
-			},
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		OSCmd := NewDummyOSCommand()
-		OSCmd.Command = s.command
-		OSCmd.Platform.OS = "linux"
-		OSCmd.Config.GetUserConfig().OS.OpenCommand = `xdg-open {{filename}} > /dev/null`
-
-		s.test(OSCmd.OpenFile(s.filename))
-	}
-}
@@ -3,6 +3,7 @@ package oscommands
 import (
 	"io/ioutil"
 	"os"
+	"os/exec"
 	"testing"

 	"github.com/stretchr/testify/assert"
@@ -57,15 +58,216 @@ func TestOSCommandRunCommand(t *testing.T) {
 	}
 }

+// TestOSCommandOpenFile is a function.
+func TestOSCommandOpenFile(t *testing.T) {
+	type scenario struct {
+		filename string
+		command  func(string, ...string) *exec.Cmd
+		test     func(error)
+	}
+
+	scenarios := []scenario{
+		{
+			"test",
+			func(name string, arg ...string) *exec.Cmd {
+				return exec.Command("exit", "1")
+			},
+			func(err error) {
+				assert.Error(t, err)
+			},
+		},
+		{
+			"test",
+			func(name string, arg ...string) *exec.Cmd {
+				assert.Equal(t, "open", name)
+				assert.Equal(t, []string{"test"}, arg)
+				return exec.Command("echo")
+			},
+			func(err error) {
+				assert.NoError(t, err)
+			},
+		},
+		{
+			"filename with spaces",
+			func(name string, arg ...string) *exec.Cmd {
+				assert.Equal(t, "open", name)
+				assert.Equal(t, []string{"filename with spaces"}, arg)
+				return exec.Command("echo")
+			},
+			func(err error) {
+				assert.NoError(t, err)
+			},
+		},
+	}
+
+	for _, s := range scenarios {
+		OSCmd := NewDummyOSCommand()
+		OSCmd.Command = s.command
+		OSCmd.Config.GetUserConfig().OS.OpenCommand = "open {{filename}}"
+
+		s.test(OSCmd.OpenFile(s.filename))
+	}
+}
+
+// TestOSCommandEditFile is a function.
+func TestOSCommandEditFile(t *testing.T) {
+	type scenario struct {
+		filename           string
+		command            func(string, ...string) *exec.Cmd
+		getenv             func(string) string
+		getGlobalGitConfig func(string) (string, error)
+		test               func(*exec.Cmd, error)
+	}
+
+	scenarios := []scenario{
+		{
+			"test",
+			func(name string, arg ...string) *exec.Cmd {
+				return exec.Command("exit", "1")
+			},
+			func(env string) string {
+				return ""
+			},
+			func(cf string) (string, error) {
+				return "", nil
+			},
+			func(cmd *exec.Cmd, err error) {
+				assert.EqualError(t, err, "No editor defined in $VISUAL, $EDITOR, or git config")
+			},
+		},
+		{
+			"test",
+			func(name string, arg ...string) *exec.Cmd {
+				if name == "which" {
+					return exec.Command("exit", "1")
+				}
+
+				assert.EqualValues(t, "nano", name)
+
+				return nil
+			},
+			func(env string) string {
+				return ""
+			},
+			func(cf string) (string, error) {
+				return "nano", nil
+			},
+			func(cmd *exec.Cmd, err error) {
+				assert.NoError(t, err)
+			},
+		},
+		{
+			"test",
+			func(name string, arg ...string) *exec.Cmd {
+				if name == "which" {
+					return exec.Command("exit", "1")
+				}
+
+				assert.EqualValues(t, "nano", name)
+
+				return nil
+			},
+			func(env string) string {
+				if env == "VISUAL" {
+					return "nano"
+				}
+
+				return ""
+			},
+			func(cf string) (string, error) {
+				return "", nil
+			},
+			func(cmd *exec.Cmd, err error) {
+				assert.NoError(t, err)
+			},
+		},
+		{
+			"test",
+			func(name string, arg ...string) *exec.Cmd {
+				if name == "which" {
+					return exec.Command("exit", "1")
+				}
+
+				assert.EqualValues(t, "emacs", name)
+
+				return nil
+			},
+			func(env string) string {
+				if env == "EDITOR" {
+					return "emacs"
+				}
+
+				return ""
+			},
+			func(cf string) (string, error) {
+				return "", nil
+			},
+			func(cmd *exec.Cmd, err error) {
+				assert.NoError(t, err)
+			},
+		},
+		{
+			"test",
+			func(name string, arg ...string) *exec.Cmd {
+				if name == "which" {
+					return exec.Command("echo")
+				}
+
+				assert.EqualValues(t, "vi", name)
+
+				return nil
+			},
+			func(env string) string {
+				return ""
+			},
+			func(cf string) (string, error) {
+				return "", nil
+			},
+			func(cmd *exec.Cmd, err error) {
+				assert.NoError(t, err)
+			},
+		},
+		{
+			"file/with space",
+			func(name string, args ...string) *exec.Cmd {
+				if name == "which" {
+					return exec.Command("echo")
+				}
+
+				assert.EqualValues(t, "vi", name)
+				assert.EqualValues(t, "file/with space", args[0])
+
+				return nil
+			},
+			func(env string) string {
+				return ""
+			},
+			func(cf string) (string, error) {
+				return "", nil
+			},
+			func(cmd *exec.Cmd, err error) {
+				assert.NoError(t, err)
+			},
+		},
+	}
+
+	for _, s := range scenarios {
+		OSCmd := NewDummyOSCommand()
+		OSCmd.Command = s.command
+		OSCmd.GetGlobalGitConfig = s.getGlobalGitConfig
+		OSCmd.Getenv = s.getenv
+
+		s.test(OSCmd.EditFile(s.filename))
+	}
+}
+
 // TestOSCommandQuote is a function.
 func TestOSCommandQuote(t *testing.T) {
 	osCommand := NewDummyOSCommand()

-	osCommand.Platform.OS = "linux"
-
 	actual := osCommand.Quote("hello `test`")

-	expected := "\"hello \\`test\\`\""
+	expected := osCommand.Platform.EscapedQuote + "hello \\`test\\`" + osCommand.Platform.EscapedQuote

 	assert.EqualValues(t, expected, actual)
 }
@@ -78,7 +280,7 @@ func TestOSCommandQuoteSingleQuote(t *testing.T) {

 	actual := osCommand.Quote("hello 'test'")

-	expected := `"hello 'test'"`
+	expected := osCommand.Platform.FallbackEscapedQuote + "hello 'test'" + osCommand.Platform.FallbackEscapedQuote

 	assert.EqualValues(t, expected, actual)
 }
@@ -91,20 +293,18 @@ func TestOSCommandQuoteDoubleQuote(t *testing.T) {

 	actual := osCommand.Quote(`hello "test"`)

-	expected := `"hello \"test\""`
+	expected := osCommand.Platform.EscapedQuote + "hello \"test\"" + osCommand.Platform.EscapedQuote

 	assert.EqualValues(t, expected, actual)
 }

-// TestOSCommandQuoteWindows tests the quote function for Windows
-func TestOSCommandQuoteWindows(t *testing.T) {
+// TestOSCommandUnquote is a function.
+func TestOSCommandUnquote(t *testing.T) {
 	osCommand := NewDummyOSCommand()

-	osCommand.Platform.OS = "windows"
+	actual := osCommand.Unquote(`hello "test"`)

-	actual := osCommand.Quote(`hello "test" 'test2'`)
-
-	expected := `\"hello "'"'"test"'"'" 'test2'\"`
+	expected := "hello test"

 	assert.EqualValues(t, expected, actual)
 }
@@ -2,8 +2,11 @@ package oscommands

 func getPlatform() *Platform {
 	return &Platform{
-		OS:       "windows",
-		Shell:    "cmd",
-		ShellArg: "/c",
+		OS:                   "windows",
+		CatCmd:               "type",
+		Shell:                "cmd",
+		ShellArg:             "/c",
+		EscapedQuote:         `\"`,
+		FallbackEscapedQuote: "\\'",
 	}
 }
@@ -1,86 +0,0 @@
-//go:build windows
-// +build windows
-
-package oscommands
-
-import (
-	"os/exec"
-	"testing"
-
-	"github.com/jesseduffield/lazygit/pkg/secureexec"
-	"github.com/stretchr/testify/assert"
-)
-
-// TestOSCommandOpenFileWindows tests the OpenFile command on Linux
-func TestOSCommandOpenFileWindows(t *testing.T) {
-	type scenario struct {
-		filename string
-		command  func(string, ...string) *exec.Cmd
-		test     func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			"test",
-			func(name string, arg ...string) *exec.Cmd {
-				return secureexec.Command("exit", "1")
-			},
-			func(err error) {
-				assert.Error(t, err)
-			},
-		},
-		{
-			"test",
-			func(name string, arg ...string) *exec.Cmd {
-				assert.Equal(t, "cmd", name)
-				assert.Equal(t, []string{"/c", "start", "", "test"}, arg)
-				return secureexec.Command("echo")
-			},
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			"filename with spaces",
-			func(name string, arg ...string) *exec.Cmd {
-				assert.Equal(t, "cmd", name)
-				assert.Equal(t, []string{"/c", "start", "", "filename with spaces"}, arg)
-				return secureexec.Command("echo")
-			},
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			"let's_test_with_single_quote",
-			func(name string, arg ...string) *exec.Cmd {
-				assert.Equal(t, "cmd", name)
-				assert.Equal(t, []string{"/c", "start", "", "let's_test_with_single_quote"}, arg)
-				return secureexec.Command("echo")
-			},
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			"$USER.txt",
-			func(name string, arg ...string) *exec.Cmd {
-				assert.Equal(t, "cmd", name)
-				assert.Equal(t, []string{"/c", "start", "", "$USER.txt"}, arg)
-				return secureexec.Command("echo")
-			},
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		OSCmd := NewDummyOSCommand()
-		OSCmd.Command = s.command
-		OSCmd.Platform.OS = "windows"
-		OSCmd.Config.GetUserConfig().OS.OpenCommand = `start "" {{filename}}`
-
-		s.test(OSCmd.OpenFile(s.filename))
-	}
-}
@@ -1,6 +1,7 @@
 package patch

 import (
+	"errors"
 	"sort"
 	"strings"

@@ -8,11 +9,9 @@ import (
 	"github.com/sirupsen/logrus"
 )

-type PatchStatus int
-
 const (
 	// UNSELECTED is for when the commit file has not been added to the patch in any way
-	UNSELECTED PatchStatus = iota
+	UNSELECTED = iota
 	// WHOLE is for when you want to add the whole diff of a file to the patch,
 	// including e.g. if it was deleted
 	WHOLE
@@ -21,7 +20,7 @@ const (
 )

 type fileInfo struct {
-	mode                PatchStatus
+	mode                int // one of WHOLE/PART
 	includedLineIndices []int
 	diff                string
 }
@@ -82,25 +81,20 @@ func (p *PatchManager) removeFile(info *fileInfo) {
 	info.includedLineIndices = nil
 }

-func (p *PatchManager) AddFileWhole(filename string) error {
+func (p *PatchManager) ToggleFileWhole(filename string) error {
 	info, err := p.getFileInfo(filename)
 	if err != nil {
 		return err
 	}
-
-	p.addFileWhole(info)
-
-	return nil
-}
-
-func (p *PatchManager) RemoveFile(filename string) error {
-	info, err := p.getFileInfo(filename)
-	if err != nil {
-		return err
+	switch info.mode {
+	case UNSELECTED, PART:
+		p.addFileWhole(info)
+	case WHOLE:
+		p.removeFile(info)
+	default:
+		return errors.New("unknown file mode")
 	}

-	p.removeFile(info)
-
 	return nil
 }

@@ -182,8 +176,11 @@ func (p *PatchManager) RenderPatchForFile(filename string, plain bool, reverse b
 	if plain {
 		return patch
 	}
-	parser := NewPatchParser(p.Log, patch)
-
+	parser, err := NewPatchParser(p.Log, patch)
+	if err != nil {
+		// swallowing for now
+		return ""
+	}
 	// not passing included lines because we don't want to see them in the secondary panel
 	return parser.Render(-1, -1, nil)
 }
@@ -219,11 +216,7 @@ func (p *PatchManager) RenderAggregatedPatchColored(plain bool) string {
 	return result
 }

-func (p *PatchManager) GetFileStatus(filename string, parent string) PatchStatus {
-	if parent != p.To {
-		return UNSELECTED
-	}
-
+func (p *PatchManager) GetFileStatus(filename string) int {
 	info, ok := p.fileInfoMap[filename]
 	if !ok {
 		return UNSELECTED
@@ -138,14 +138,7 @@ func ModifiedPatchForLines(log *logrus.Entry, filename string, diffText string,

 // I want to know, given a hunk, what line a given index is on
 func (hunk *PatchHunk) LineNumberOfLine(idx int) int {
-	n := idx - hunk.FirstLineIdx - 1
-	if n < 0 {
-		n = 0
-	} else if n >= len(hunk.bodyLines) {
-		n = len(hunk.bodyLines) - 1
-	}
-
-	lines := hunk.bodyLines[0:n]
+	lines := hunk.bodyLines[0 : idx-hunk.FirstLineIdx-1]

 	offset := nLinesWithPrefix(lines, []string{"+", " "})

@@ -4,16 +4,14 @@ import (
 	"regexp"
 	"strings"

-	"github.com/jesseduffield/lazygit/pkg/gui/style"
+	"github.com/fatih/color"
 	"github.com/jesseduffield/lazygit/pkg/theme"
 	"github.com/jesseduffield/lazygit/pkg/utils"
 	"github.com/sirupsen/logrus"
 )

-type PatchLineKind int
-
 const (
-	PATCH_HEADER PatchLineKind = iota
+	PATCH_HEADER = iota
 	COMMIT_SHA
 	COMMIT_DESCRIPTION
 	HUNK_HEADER
@@ -26,7 +24,7 @@ const (
 // the job of this file is to parse a diff, find out where the hunks begin and end, which lines are stageable, and how to find the next hunk from the current position or the next stageable line from the current position.

 type PatchLine struct {
-	Kind    PatchLineKind
+	Kind    int
 	Content string // something like '+ hello' (note the first character is not removed)
 }

@@ -39,8 +37,11 @@ type PatchParser struct {
 }

 // NewPatchParser builds a new branch list builder
-func NewPatchParser(log *logrus.Entry, patch string) *PatchParser {
-	hunkStarts, stageableLines, patchLines := parsePatch(patch)
+func NewPatchParser(log *logrus.Entry, patch string) (*PatchParser, error) {
+	hunkStarts, stageableLines, patchLines, err := parsePatch(patch)
+	if err != nil {
+		return nil, err
+	}

 	patchHunks := GetHunksFromDiff(patch)

@@ -50,7 +51,7 @@ func NewPatchParser(log *logrus.Entry, patch string) *PatchParser {
 		StageableLines: stageableLines,
 		PatchLines:     patchLines,
 		PatchHunks:     patchHunks,
-	}
+	}, nil
 }

 // GetHunkContainingLine takes a line index and an offset and finds the hunk
@@ -95,49 +96,55 @@ func (l *PatchLine) render(selected bool, included bool) string {
 	if l.Kind == HUNK_HEADER {
 		re := regexp.MustCompile("(@@.*?@@)(.*)")
 		match := re.FindStringSubmatch(content)
-		return coloredString(style.FgCyan, match[1], selected, included) + coloredString(theme.DefaultTextColor, match[2], selected, false)
+		return coloredString(color.FgCyan, match[1], selected, included) + coloredString(theme.DefaultTextColor, match[2], selected, false)
 	}

-	textStyle := theme.DefaultTextColor
+	var colorAttr color.Attribute
 	switch l.Kind {
 	case PATCH_HEADER:
-		textStyle = textStyle.SetBold()
+		colorAttr = color.Bold
 	case ADDITION:
-		textStyle = style.FgGreen
+		colorAttr = color.FgGreen
 	case DELETION:
-		textStyle = style.FgRed
+		colorAttr = color.FgRed
 	case COMMIT_SHA:
-		textStyle = style.FgYellow
+		colorAttr = color.FgYellow
+	default:
+		colorAttr = theme.DefaultTextColor
 	}

-	return coloredString(textStyle, content, selected, included)
+	return coloredString(colorAttr, content, selected, included)
 }

-func coloredString(textStyle style.TextStyle, str string, selected bool, included bool) string {
+func coloredString(colorAttr color.Attribute, str string, selected bool, included bool) string {
+	var cl *color.Color
+	attributes := []color.Attribute{colorAttr}
 	if selected {
-		textStyle = textStyle.MergeStyle(theme.SelectedRangeBgColor)
+		attributes = append(attributes, theme.SelectedRangeBgColor)
 	}
-
-	firstCharStyle := textStyle
+	cl = color.New(attributes...)
+	var clIncluded *color.Color
 	if included {
-		firstCharStyle = firstCharStyle.MergeStyle(style.BgGreen)
+		clIncluded = color.New(append(attributes, color.BgGreen)...)
+	} else {
+		clIncluded = color.New(attributes...)
 	}

 	if len(str) < 2 {
-		return firstCharStyle.Sprint(str)
+		return utils.ColoredStringDirect(str, clIncluded)
 	}

-	return firstCharStyle.Sprint(str[:1]) + textStyle.Sprint(str[1:])
+	return utils.ColoredStringDirect(str[:1], clIncluded) + utils.ColoredStringDirect(str[1:], cl)
 }

-func parsePatch(patch string) ([]int, []int, []*PatchLine) {
+func parsePatch(patch string) ([]int, []int, []*PatchLine, error) {
 	lines := strings.Split(patch, "\n")
 	hunkStarts := []int{}
 	stageableLines := []int{}
 	pastFirstHunkHeader := false
 	pastCommitDescription := true
 	patchLines := make([]*PatchLine, len(lines))
-	var lineKind PatchLineKind
+	var lineKind int
 	var firstChar string
 	for index, line := range lines {
 		firstChar = " "
@@ -176,7 +183,7 @@ func parsePatch(patch string) ([]int, []int, []*PatchLine) {
 		}
 		patchLines[index] = &PatchLine{Kind: lineKind, Content: line}
 	}
-	return hunkStarts, stageableLines, patchLines
+	return hunkStarts, stageableLines, patchLines, nil
 }

 // Render returns the coloured string of the diff with any selected lines highlighted
@@ -194,19 +201,6 @@ func (p *PatchParser) Render(firstLineIndex int, lastLineIndex int, incLineIndic
 	return result
 }

-// PlainRenderLines returns the non-coloured string of diff part from firstLineIndex to
-// lastLineIndex
-func (p *PatchParser) PlainRenderLines(firstLineIndex, lastLineIndex int) string {
-	linesToCopy := p.PatchLines[firstLineIndex : lastLineIndex+1]
-
-	renderedLines := make([]string, len(linesToCopy))
-	for index, line := range linesToCopy {
-		renderedLines[index] = line.Content
-	}
-
-	return strings.Join(renderedLines, "\n")
-}
-
 // GetNextStageableLineIndex takes a line index and returns the line index of the next stageable line
 // note this will actually include the current index if it is stageable
 func (p *PatchParser) GetNextStageableLineIndex(currentIndex int) int {
@@ -23,7 +23,7 @@ func (c *GitCommand) DeletePatchesFromCommit(commits []*models.Commit, commitInd
 	}

 	// time to amend the selected commit
-	if err := c.AmendHead(); err != nil {
+	if _, err := c.AmendHead(); err != nil {
 		return err
 	}

@@ -51,7 +51,7 @@ func (c *GitCommand) MovePatchToSelectedCommit(commits []*models.Commit, sourceC
 		}

 		// amend the destination commit
-		if err := c.AmendHead(); err != nil {
+		if _, err := c.AmendHead(); err != nil {
 			return err
 		}

@@ -71,7 +71,7 @@ func (c *GitCommand) MovePatchToSelectedCommit(commits []*models.Commit, sourceC
 	// 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() {
+	if c.usingGpg() {
 		return errors.New(c.Tr.DisabledForGPG)
 	}

@@ -103,7 +103,7 @@ func (c *GitCommand) MovePatchToSelectedCommit(commits []*models.Commit, sourceC
 	}

 	// amend the source commit
-	if err := c.AmendHead(); err != nil {
+	if _, err := c.AmendHead(); err != nil {
 		return err
 	}

@@ -122,7 +122,7 @@ func (c *GitCommand) MovePatchToSelectedCommit(commits []*models.Commit, sourceC
 		}

 		// amend the destination commit
-		if err := c.AmendHead(); err != nil {
+		if _, err := c.AmendHead(); err != nil {
 			return err
 		}

@@ -137,7 +137,7 @@ func (c *GitCommand) MovePatchToSelectedCommit(commits []*models.Commit, sourceC
 	return c.GenericMergeOrRebaseAction("rebase", "continue")
 }

-func (c *GitCommand) MovePatchIntoIndex(commits []*models.Commit, commitIdx int, p *patch.PatchManager, stash bool) error {
+func (c *GitCommand) PullPatchIntoIndex(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
@@ -149,7 +149,7 @@ func (c *GitCommand) MovePatchIntoIndex(commits []*models.Commit, commitIdx int,
 	}

 	if err := p.ApplyPatches(true); err != nil {
-		if c.WorkingTreeState() == REBASE_MODE_REBASING {
+		if c.WorkingTreeState() == "rebasing" {
 			if err := c.GenericMergeOrRebaseAction("rebase", "abort"); err != nil {
 				return err
 			}
@@ -158,7 +158,7 @@ func (c *GitCommand) MovePatchIntoIndex(commits []*models.Commit, commitIdx int,
 	}

 	// amend the commit
-	if err := c.AmendHead(); err != nil {
+	if _, err := c.AmendHead(); err != nil {
 		return err
 	}

@@ -169,7 +169,7 @@ func (c *GitCommand) MovePatchIntoIndex(commits []*models.Commit, commitIdx int,
 	c.onSuccessfulContinue = func() error {
 		// add patches to index
 		if err := p.ApplyPatches(false); err != nil {
-			if c.WorkingTreeState() == REBASE_MODE_REBASING {
+			if c.WorkingTreeState() == "rebasing" {
 				if err := c.GenericMergeOrRebaseAction("rebase", "abort"); err != nil {
 					return err
 				}
@@ -203,7 +203,7 @@ func (c *GitCommand) PullPatchIntoNewCommit(commits []*models.Commit, commitIdx
 	}

 	// amend the commit
-	if err := c.AmendHead(); err != nil {
+	if _, err := c.AmendHead(); err != nil {
 		return err
 	}

@@ -217,7 +217,7 @@ func (c *GitCommand) PullPatchIntoNewCommit(commits []*models.Commit, commitIdx

 	head_message, _ := c.GetHeadCommitMessage()
 	new_message := fmt.Sprintf("Split from \"%s\"", head_message)
-	err := c.OSCommand.RunCommand(c.CommitCmdStr(new_message, ""))
+	_, err := c.Commit(new_message, "")
 	if err != nil {
 		return err
 	}
@@ -5,62 +5,14 @@ import (
 	"strings"

 	"github.com/go-errors/errors"
+	"github.com/jesseduffield/lazygit/pkg/commands/models"
 	"github.com/jesseduffield/lazygit/pkg/config"
 )

 // Service is a service that repository is on (Github, Bitbucket, ...)
 type Service struct {
-	Name                            string
-	pullRequestURLIntoDefaultBranch func(owner string, repository string, from string) string
-	pullRequestURLIntoTargetBranch  func(owner string, repository string, from string, to string) string
-}
-
-// NewService builds a Service based on the host type
-func NewService(typeName string, repositoryDomain string, siteDomain string) *Service {
-	var service *Service
-
-	switch typeName {
-	case "github":
-		service = &Service{
-			Name: repositoryDomain,
-			pullRequestURLIntoDefaultBranch: func(owner string, repository string, from string) string {
-				return fmt.Sprintf("https://%s/%s/%s/compare/%s?expand=1", siteDomain, owner, repository, from)
-			},
-			pullRequestURLIntoTargetBranch: func(owner string, repository string, from string, to string) string {
-				return fmt.Sprintf("https://%s/%s/%s/compare/%s...%s?expand=1", siteDomain, owner, repository, to, from)
-			},
-		}
-	case "bitbucket":
-		service = &Service{
-			Name: repositoryDomain,
-			pullRequestURLIntoDefaultBranch: func(owner string, repository string, from string) string {
-				return fmt.Sprintf("https://%s/%s/%s/pull-requests/new?source=%s&t=1", siteDomain, owner, repository, from)
-			},
-			pullRequestURLIntoTargetBranch: func(owner string, repository string, from string, to string) string {
-				return fmt.Sprintf("https://%s/%s/%s/pull-requests/new?source=%s&dest=%s&t=1", siteDomain, owner, repository, from, to)
-			},
-		}
-	case "gitlab":
-		service = &Service{
-			Name: repositoryDomain,
-			pullRequestURLIntoDefaultBranch: func(owner string, repository string, from string) string {
-				return fmt.Sprintf("https://%s/%s/%s/merge_requests/new?merge_request[source_branch]=%s", siteDomain, owner, repository, from)
-			},
-			pullRequestURLIntoTargetBranch: func(owner string, repository string, from string, to string) string {
-				return fmt.Sprintf("https://%s/%s/%s/merge_requests/new?merge_request[source_branch]=%s&merge_request[target_branch]=%s", siteDomain, owner, repository, from, to)
-			},
-		}
-	}
-
-	return service
-}
-
-func (s *Service) PullRequestURL(owner string, repository string, from string, to string) string {
-	if to == "" {
-		return s.pullRequestURLIntoDefaultBranch(owner, repository, from)
-	} else {
-		return s.pullRequestURLIntoTargetBranch(owner, repository, from, to)
-	}
+	Name           string
+	PullRequestURL string
 }

 // PullRequest opens a link in browser to create new pull request
@@ -76,6 +28,31 @@ type RepoInformation struct {
 	Repository string
 }

+// NewService builds a Service based on the host type
+func NewService(typeName string, repositoryDomain string, siteDomain string) *Service {
+	var service *Service
+
+	switch typeName {
+	case "github":
+		service = &Service{
+			Name:           repositoryDomain,
+			PullRequestURL: fmt.Sprintf("https://%s%s", siteDomain, "/%s/%s/compare/%s?expand=1"),
+		}
+	case "bitbucket":
+		service = &Service{
+			Name:           repositoryDomain,
+			PullRequestURL: fmt.Sprintf("https://%s%s", siteDomain, "/%s/%s/pull-requests/new?source=%s&t=1"),
+		}
+	case "gitlab":
+		service = &Service{
+			Name:           repositoryDomain,
+			PullRequestURL: fmt.Sprintf("https://%s%s", siteDomain, "/%s/%s/merge_requests/new?merge_request[source_branch]=%s"),
+		}
+	}
+
+	return service
+}
+
 func getServices(config config.AppConfigurer) []*Service {
 	services := []*Service{
 		NewService("github", "github.com", "github.com"),
@@ -113,30 +90,11 @@ func NewPullRequest(gitCommand *GitCommand) *PullRequest {
 }

 // Create opens link to new pull request in browser
-func (pr *PullRequest) Create(from string, to string) (string, error) {
-	pullRequestURL, err := pr.getPullRequestURL(from, to)
-	if err != nil {
-		return "", err
-	}
-
-	return pullRequestURL, pr.GitCommand.OSCommand.OpenLink(pullRequestURL)
-}
-
-// CopyURL copies the pull request URL to the clipboard
-func (pr *PullRequest) CopyURL(from string, to string) (string, error) {
-	pullRequestURL, err := pr.getPullRequestURL(from, to)
-	if err != nil {
-		return "", err
-	}
-
-	return pullRequestURL, pr.GitCommand.OSCommand.CopyToClipboard(pullRequestURL)
-}
-
-func (pr *PullRequest) getPullRequestURL(from string, to string) (string, error) {
-	branchExistsOnRemote := pr.GitCommand.CheckRemoteBranchExists(from)
+func (pr *PullRequest) Create(branch *models.Branch) error {
+	branchExistsOnRemote := pr.GitCommand.CheckRemoteBranchExists(branch)

 	if !branchExistsOnRemote {
-		return "", errors.New(pr.GitCommand.Tr.NoBranchOnRemote)
+		return errors.New(pr.GitCommand.Tr.NoBranchOnRemote)
 	}

 	repoURL := pr.GitCommand.GetRemoteURL()
@@ -150,14 +108,14 @@ func (pr *PullRequest) getPullRequestURL(from string, to string) (string, error)
 	}

 	if gitService == nil {
-		return "", errors.New(pr.GitCommand.Tr.UnsupportedGitService)
+		return errors.New(pr.GitCommand.Tr.UnsupportedGitService)
 	}

 	repoInfo := getRepoInfoFromURL(repoURL)

-	pullRequestURL := gitService.PullRequestURL(repoInfo.Owner, repoInfo.Repository, from, to)
-
-	return pullRequestURL, nil
+	return pr.GitCommand.OSCommand.OpenLink(fmt.Sprintf(
+		gitService.PullRequestURL, repoInfo.Owner, repoInfo.Repository, branch.Name,
+	))
 }

 func getRepoInfoFromURL(url string) *RepoInformation {
@@ -1,256 +0,0 @@
-//go:build !windows
-// +build !windows
-
-package commands
-
-import (
-	"os/exec"
-	"strings"
-	"testing"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/git_config"
-	"github.com/jesseduffield/lazygit/pkg/secureexec"
-	"github.com/stretchr/testify/assert"
-)
-
-// TestCreatePullRequest is a function.
-func TestCreatePullRequest(t *testing.T) {
-	type scenario struct {
-		testName  string
-		from      string
-		to        string
-		remoteUrl string
-		command   func(string, ...string) *exec.Cmd
-		test      func(url string, err error)
-	}
-
-	scenarios := []scenario{
-		{
-			testName:  "Opens a link to new pull request on bitbucket",
-			from:      "feature/profile-page",
-			remoteUrl: "git@bitbucket.org:johndoe/social_network.git",
-			command: func(cmd string, args ...string) *exec.Cmd {
-				// Handle git remote url call
-				if strings.HasPrefix(cmd, "git") {
-					return secureexec.Command("echo", "git@bitbucket.org:johndoe/social_network.git")
-				}
-
-				assert.Equal(t, cmd, "bash")
-				assert.Equal(t, args, []string{"-c", `open "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/profile-page&t=1"`})
-				return secureexec.Command("echo")
-			},
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/profile-page&t=1", url)
-			},
-		},
-		{
-			testName:  "Opens a link to new pull request on bitbucket with http remote url",
-			from:      "feature/events",
-			remoteUrl: "https://my_username@bitbucket.org/johndoe/social_network.git",
-			command: func(cmd string, args ...string) *exec.Cmd {
-				// Handle git remote url call
-				if strings.HasPrefix(cmd, "git") {
-					return secureexec.Command("echo", "https://my_username@bitbucket.org/johndoe/social_network.git")
-				}
-
-				assert.Equal(t, cmd, "bash")
-				assert.Equal(t, args, []string{"-c", `open "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/events&t=1"`})
-				return secureexec.Command("echo")
-			},
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/events&t=1", url)
-			},
-		},
-		{
-			testName:  "Opens a link to new pull request on github",
-			from:      "feature/sum-operation",
-			remoteUrl: "git@github.com:peter/calculator.git",
-			command: func(cmd string, args ...string) *exec.Cmd {
-				// Handle git remote url call
-				if strings.HasPrefix(cmd, "git") {
-					return secureexec.Command("echo", "git@github.com:peter/calculator.git")
-				}
-
-				assert.Equal(t, cmd, "bash")
-				assert.Equal(t, args, []string{"-c", `open "https://github.com/peter/calculator/compare/feature/sum-operation?expand=1"`})
-				return secureexec.Command("echo")
-			},
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://github.com/peter/calculator/compare/feature/sum-operation?expand=1", url)
-			},
-		},
-		{
-			testName:  "Opens a link to new pull request on bitbucket with specific target branch",
-			from:      "feature/profile-page/avatar",
-			to:        "feature/profile-page",
-			remoteUrl: "git@bitbucket.org:johndoe/social_network.git",
-			command: func(cmd string, args ...string) *exec.Cmd {
-				// Handle git remote url call
-				if strings.HasPrefix(cmd, "git") {
-					return secureexec.Command("echo", "git@bitbucket.org:johndoe/social_network.git")
-				}
-
-				assert.Equal(t, cmd, "bash")
-				assert.Equal(t, args, []string{"-c", `open "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/profile-page/avatar&dest=feature/profile-page&t=1"`})
-				return secureexec.Command("echo")
-			},
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/profile-page/avatar&dest=feature/profile-page&t=1", url)
-			},
-		},
-		{
-			testName:  "Opens a link to new pull request on bitbucket with http remote url with specified target branch",
-			from:      "feature/remote-events",
-			to:        "feature/events",
-			remoteUrl: "https://my_username@bitbucket.org/johndoe/social_network.git",
-			command: func(cmd string, args ...string) *exec.Cmd {
-				// Handle git remote url call
-				if strings.HasPrefix(cmd, "git") {
-					return secureexec.Command("echo", "https://my_username@bitbucket.org/johndoe/social_network.git")
-				}
-
-				assert.Equal(t, cmd, "bash")
-				assert.Equal(t, args, []string{"-c", `open "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/remote-events&dest=feature/events&t=1"`})
-				return secureexec.Command("echo")
-			},
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/remote-events&dest=feature/events&t=1", url)
-			},
-		},
-		{
-			testName:  "Opens a link to new pull request on github with specific target branch",
-			from:      "feature/sum-operation",
-			to:        "feature/operations",
-			remoteUrl: "git@github.com:peter/calculator.git",
-			command: func(cmd string, args ...string) *exec.Cmd {
-				// Handle git remote url call
-				if strings.HasPrefix(cmd, "git") {
-					return secureexec.Command("echo", "git@github.com:peter/calculator.git")
-				}
-
-				assert.Equal(t, cmd, "bash")
-				assert.Equal(t, args, []string{"-c", `open "https://github.com/peter/calculator/compare/feature/operations...feature/sum-operation?expand=1"`})
-				return secureexec.Command("echo")
-			},
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://github.com/peter/calculator/compare/feature/operations...feature/sum-operation?expand=1", url)
-			},
-		},
-		{
-			testName:  "Opens a link to new pull request on gitlab",
-			from:      "feature/ui",
-			remoteUrl: "git@gitlab.com:peter/calculator.git",
-			command: func(cmd string, args ...string) *exec.Cmd {
-				// Handle git remote url call
-				if strings.HasPrefix(cmd, "git") {
-					return secureexec.Command("echo", "git@gitlab.com:peter/calculator.git")
-				}
-
-				assert.Equal(t, cmd, "bash")
-				assert.Equal(t, args, []string{"-c", `open "https://gitlab.com/peter/calculator/merge_requests/new?merge_request[source_branch]=feature/ui"`})
-				return secureexec.Command("echo")
-			},
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://gitlab.com/peter/calculator/merge_requests/new?merge_request[source_branch]=feature/ui", url)
-			},
-		},
-		{
-			testName:  "Opens a link to new pull request on gitlab in nested groups",
-			from:      "feature/ui",
-			remoteUrl: "git@gitlab.com:peter/public/calculator.git",
-			command: func(cmd string, args ...string) *exec.Cmd {
-				// Handle git remote url call
-				if strings.HasPrefix(cmd, "git") {
-					return secureexec.Command("echo", "git@gitlab.com:peter/calculator.git")
-				}
-
-				assert.Equal(t, cmd, "bash")
-				assert.Equal(t, args, []string{"-c", `open "https://gitlab.com/peter/public/calculator/merge_requests/new?merge_request[source_branch]=feature/ui"`})
-				return secureexec.Command("echo")
-			},
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://gitlab.com/peter/public/calculator/merge_requests/new?merge_request[source_branch]=feature/ui", url)
-			},
-		},
-		{
-			testName:  "Opens a link to new pull request on gitlab with specific target branch",
-			from:      "feature/commit-ui",
-			to:        "epic/ui",
-			remoteUrl: "git@gitlab.com:peter/calculator.git",
-			command: func(cmd string, args ...string) *exec.Cmd {
-				// Handle git remote url call
-				if strings.HasPrefix(cmd, "git") {
-					return secureexec.Command("echo", "git@gitlab.com:peter/calculator.git")
-				}
-
-				assert.Equal(t, cmd, "bash")
-				assert.Equal(t, args, []string{"-c", `open "https://gitlab.com/peter/calculator/merge_requests/new?merge_request[source_branch]=feature/commit-ui&merge_request[target_branch]=epic/ui"`})
-				return secureexec.Command("echo")
-			},
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://gitlab.com/peter/calculator/merge_requests/new?merge_request[source_branch]=feature/commit-ui&merge_request[target_branch]=epic/ui", url)
-			},
-		},
-		{
-			testName:  "Opens a link to new pull request on gitlab with specific target branch in nested groups",
-			from:      "feature/commit-ui",
-			to:        "epic/ui",
-			remoteUrl: "git@gitlab.com:peter/public/calculator.git",
-			command: func(cmd string, args ...string) *exec.Cmd {
-				// Handle git remote url call
-				if strings.HasPrefix(cmd, "git") {
-					return secureexec.Command("echo", "git@gitlab.com:peter/calculator.git")
-				}
-
-				assert.Equal(t, cmd, "bash")
-				assert.Equal(t, args, []string{"-c", `open "https://gitlab.com/peter/public/calculator/merge_requests/new?merge_request[source_branch]=feature/commit-ui&merge_request[target_branch]=epic/ui"`})
-				return secureexec.Command("echo")
-			},
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://gitlab.com/peter/public/calculator/merge_requests/new?merge_request[source_branch]=feature/commit-ui&merge_request[target_branch]=epic/ui", url)
-			},
-		},
-		{
-			testName:  "Throws an error if git service is unsupported",
-			from:      "feature/divide-operation",
-			remoteUrl: "git@something.com:peter/calculator.git",
-			command: func(cmd string, args ...string) *exec.Cmd {
-				return secureexec.Command("echo")
-			},
-			test: func(url string, err error) {
-				assert.Error(t, err)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCommand := NewDummyGitCommand()
-			gitCommand.OSCommand.Command = s.command
-			gitCommand.OSCommand.Platform.OS = "darwin"
-			gitCommand.OSCommand.Platform.Shell = "bash"
-			gitCommand.OSCommand.Platform.ShellArg = "-c"
-			gitCommand.OSCommand.Config.GetUserConfig().OS.OpenLinkCommand = "open {{link}}"
-			gitCommand.OSCommand.Config.GetUserConfig().Services = map[string]string{
-				// valid configuration for a custom service URL
-				"git.work.com": "gitlab:code.work.com",
-				// invalid configurations for a custom service URL
-				"invalid.work.com":   "noservice:invalid.work.com",
-				"noservice.work.com": "noservice.work.com",
-			}
-			gitCommand.GitConfig = git_config.NewFakeGitConfig(map[string]string{"remote.origin.url": s.remoteUrl})
-			dummyPullRequest := NewPullRequest(gitCommand)
-			s.test(dummyPullRequest.Create(s.from, s.to))
-		})
-	}
-}
@@ -1,8 +1,11 @@
 package commands

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

+	"github.com/jesseduffield/lazygit/pkg/commands/models"
 	"github.com/stretchr/testify/assert"
 )

@@ -39,3 +42,121 @@ func TestGetRepoInfoFromURL(t *testing.T) {
 		})
 	}
 }
+
+// TestCreatePullRequest is a function.
+func TestCreatePullRequest(t *testing.T) {
+	type scenario struct {
+		testName string
+		branch   *models.Branch
+		command  func(string, ...string) *exec.Cmd
+		test     func(err error)
+	}
+
+	scenarios := []scenario{
+		{
+			"Opens a link to new pull request on bitbucket",
+			&models.Branch{
+				Name: "feature/profile-page",
+			},
+			func(cmd string, args ...string) *exec.Cmd {
+				// Handle git remote url call
+				if strings.HasPrefix(cmd, "git") {
+					return exec.Command("echo", "git@bitbucket.org:johndoe/social_network.git")
+				}
+
+				assert.Equal(t, cmd, "open")
+				assert.Equal(t, args, []string{"https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/profile-page&t=1"})
+				return exec.Command("echo")
+			},
+			func(err error) {
+				assert.NoError(t, err)
+			},
+		},
+		{
+			"Opens a link to new pull request on bitbucket with http remote url",
+			&models.Branch{
+				Name: "feature/events",
+			},
+			func(cmd string, args ...string) *exec.Cmd {
+				// Handle git remote url call
+				if strings.HasPrefix(cmd, "git") {
+					return exec.Command("echo", "https://my_username@bitbucket.org/johndoe/social_network.git")
+				}
+
+				assert.Equal(t, cmd, "open")
+				assert.Equal(t, args, []string{"https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/events&t=1"})
+				return exec.Command("echo")
+			},
+			func(err error) {
+				assert.NoError(t, err)
+			},
+		},
+		{
+			"Opens a link to new pull request on github",
+			&models.Branch{
+				Name: "feature/sum-operation",
+			},
+			func(cmd string, args ...string) *exec.Cmd {
+				// Handle git remote url call
+				if strings.HasPrefix(cmd, "git") {
+					return exec.Command("echo", "git@github.com:peter/calculator.git")
+				}
+
+				assert.Equal(t, cmd, "open")
+				assert.Equal(t, args, []string{"https://github.com/peter/calculator/compare/feature/sum-operation?expand=1"})
+				return exec.Command("echo")
+			},
+			func(err error) {
+				assert.NoError(t, err)
+			},
+		},
+		{
+			"Opens a link to new pull request on gitlab",
+			&models.Branch{
+				Name: "feature/ui",
+			},
+			func(cmd string, args ...string) *exec.Cmd {
+				// Handle git remote url call
+				if strings.HasPrefix(cmd, "git") {
+					return exec.Command("echo", "git@gitlab.com:peter/calculator.git")
+				}
+
+				assert.Equal(t, cmd, "open")
+				assert.Equal(t, args, []string{"https://gitlab.com/peter/calculator/merge_requests/new?merge_request[source_branch]=feature/ui"})
+				return exec.Command("echo")
+			},
+			func(err error) {
+				assert.NoError(t, err)
+			},
+		},
+		{
+			"Throws an error if git service is unsupported",
+			&models.Branch{
+				Name: "feature/divide-operation",
+			},
+			func(cmd string, args ...string) *exec.Cmd {
+				return exec.Command("echo", "git@something.com:peter/calculator.git")
+			},
+			func(err error) {
+				assert.Error(t, err)
+			},
+		},
+	}
+
+	for _, s := range scenarios {
+		t.Run(s.testName, func(t *testing.T) {
+			gitCommand := NewDummyGitCommand()
+			gitCommand.OSCommand.Command = s.command
+			gitCommand.OSCommand.Config.GetUserConfig().OS.OpenLinkCommand = "open {{link}}"
+			gitCommand.OSCommand.Config.GetUserConfig().Services = map[string]string{
+				// valid configuration for a custom service URL
+				"git.work.com": "gitlab:code.work.com",
+				// invalid configurations for a custom service URL
+				"invalid.work.com":   "noservice:invalid.work.com",
+				"noservice.work.com": "noservice.work.com",
+			}
+			dummyPullRequest := NewPullRequest(gitCommand)
+			s.test(dummyPullRequest.Create(s.branch))
+		})
+	}
+}
@@ -1,256 +0,0 @@
-//go:build windows
-// +build windows
-
-package commands
-
-import (
-	"os/exec"
-	"strings"
-	"testing"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/git_config"
-	"github.com/jesseduffield/lazygit/pkg/secureexec"
-	"github.com/stretchr/testify/assert"
-)
-
-// TestCreatePullRequestOnWindows is a function.
-func TestCreatePullRequestOnWindows(t *testing.T) {
-	type scenario struct {
-		testName  string
-		from      string
-		to        string
-		remoteUrl string
-		command   func(string, ...string) *exec.Cmd
-		test      func(url string, err error)
-	}
-
-	scenarios := []scenario{
-		{
-			testName:  "Opens a link to new pull request on bitbucket",
-			from:      "feature/profile-page",
-			remoteUrl: "git@bitbucket.org:johndoe/social_network.git",
-			command: func(cmd string, args ...string) *exec.Cmd {
-				// Handle git remote url call
-				if strings.HasPrefix(cmd, "git") {
-					return secureexec.Command("echo", "git@bitbucket.org:johndoe/social_network.git")
-				}
-
-				assert.Equal(t, cmd, "cmd")
-				assert.Equal(t, args, []string{"/c", "start", "", "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/profile-page^&t=1"})
-				return secureexec.Command("echo")
-			},
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/profile-page&t=1", url)
-			},
-		},
-		{
-			testName:  "Opens a link to new pull request on bitbucket with http remote url",
-			from:      "feature/events",
-			remoteUrl: "https://my_username@bitbucket.org/johndoe/social_network.git",
-			command: func(cmd string, args ...string) *exec.Cmd {
-				// Handle git remote url call
-				if strings.HasPrefix(cmd, "git") {
-					return secureexec.Command("echo", "https://my_username@bitbucket.org/johndoe/social_network.git")
-				}
-
-				assert.Equal(t, cmd, "cmd")
-				assert.Equal(t, args, []string{"/c", "start", "", "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/events^&t=1"})
-				return secureexec.Command("echo")
-			},
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/events&t=1", url)
-			},
-		},
-		{
-			testName:  "Opens a link to new pull request on github",
-			from:      "feature/sum-operation",
-			remoteUrl: "git@github.com:peter/calculator.git",
-			command: func(cmd string, args ...string) *exec.Cmd {
-				// Handle git remote url call
-				if strings.HasPrefix(cmd, "git") {
-					return secureexec.Command("echo", "git@github.com:peter/calculator.git")
-				}
-
-				assert.Equal(t, cmd, "cmd")
-				assert.Equal(t, args, []string{"/c", "start", "", "https://github.com/peter/calculator/compare/feature/sum-operation?expand=1"})
-				return secureexec.Command("echo")
-			},
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://github.com/peter/calculator/compare/feature/sum-operation?expand=1", url)
-			},
-		},
-		{
-			testName:  "Opens a link to new pull request on bitbucket with specific target branch",
-			from:      "feature/profile-page/avatar",
-			to:        "feature/profile-page",
-			remoteUrl: "git@bitbucket.org:johndoe/social_network.git",
-			command: func(cmd string, args ...string) *exec.Cmd {
-				// Handle git remote url call
-				if strings.HasPrefix(cmd, "git") {
-					return secureexec.Command("echo", "git@bitbucket.org:johndoe/social_network.git")
-				}
-
-				assert.Equal(t, cmd, "cmd")
-				assert.Equal(t, args, []string{"/c", "start", "", "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/profile-page/avatar^&dest=feature/profile-page^&t=1"})
-				return secureexec.Command("echo")
-			},
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/profile-page/avatar&dest=feature/profile-page&t=1", url)
-			},
-		},
-		{
-			testName:  "Opens a link to new pull request on bitbucket with http remote url with specified target branch",
-			from:      "feature/remote-events",
-			to:        "feature/events",
-			remoteUrl: "https://my_username@bitbucket.org/johndoe/social_network.git",
-			command: func(cmd string, args ...string) *exec.Cmd {
-				// Handle git remote url call
-				if strings.HasPrefix(cmd, "git") {
-					return secureexec.Command("echo", "https://my_username@bitbucket.org/johndoe/social_network.git")
-				}
-
-				assert.Equal(t, cmd, "cmd")
-				assert.Equal(t, args, []string{"/c", "start", "", "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/remote-events^&dest=feature/events^&t=1"})
-				return secureexec.Command("echo")
-			},
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/remote-events&dest=feature/events&t=1", url)
-			},
-		},
-		{
-			testName:  "Opens a link to new pull request on github with specific target branch",
-			from:      "feature/sum-operation",
-			to:        "feature/operations",
-			remoteUrl: "git@github.com:peter/calculator.git",
-			command: func(cmd string, args ...string) *exec.Cmd {
-				// Handle git remote url call
-				if strings.HasPrefix(cmd, "git") {
-					return secureexec.Command("echo", "git@github.com:peter/calculator.git")
-				}
-
-				assert.Equal(t, cmd, "cmd")
-				assert.Equal(t, args, []string{"/c", "start", "", "https://github.com/peter/calculator/compare/feature/operations...feature/sum-operation?expand=1"})
-				return secureexec.Command("echo")
-			},
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://github.com/peter/calculator/compare/feature/operations...feature/sum-operation?expand=1", url)
-			},
-		},
-		{
-			testName:  "Opens a link to new pull request on gitlab",
-			from:      "feature/ui",
-			remoteUrl: "git@gitlab.com:peter/calculator.git",
-			command: func(cmd string, args ...string) *exec.Cmd {
-				// Handle git remote url call
-				if strings.HasPrefix(cmd, "git") {
-					return secureexec.Command("echo", "git@gitlab.com:peter/calculator.git")
-				}
-
-				assert.Equal(t, cmd, "cmd")
-				assert.Equal(t, args, []string{"/c", "start", "", "https://gitlab.com/peter/calculator/merge_requests/new?merge_request[source_branch]=feature/ui"})
-				return secureexec.Command("echo")
-			},
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://gitlab.com/peter/calculator/merge_requests/new?merge_request[source_branch]=feature/ui", url)
-			},
-		},
-		{
-			testName:  "Opens a link to new pull request on gitlab in nested groups",
-			from:      "feature/ui",
-			remoteUrl: "git@gitlab.com:peter/public/calculator.git",
-			command: func(cmd string, args ...string) *exec.Cmd {
-				// Handle git remote url call
-				if strings.HasPrefix(cmd, "git") {
-					return secureexec.Command("echo", "git@gitlab.com:peter/calculator.git")
-				}
-
-				assert.Equal(t, cmd, "cmd")
-				assert.Equal(t, args, []string{"/c", "start", "", "https://gitlab.com/peter/public/calculator/merge_requests/new?merge_request[source_branch]=feature/ui"})
-				return secureexec.Command("echo")
-			},
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://gitlab.com/peter/public/calculator/merge_requests/new?merge_request[source_branch]=feature/ui", url)
-			},
-		},
-		{
-			testName:  "Opens a link to new pull request on gitlab with specific target branch",
-			from:      "feature/commit-ui",
-			to:        "epic/ui",
-			remoteUrl: "git@gitlab.com:peter/calculator.git",
-			command: func(cmd string, args ...string) *exec.Cmd {
-				// Handle git remote url call
-				if strings.HasPrefix(cmd, "git") {
-					return secureexec.Command("echo", "git@gitlab.com:peter/calculator.git")
-				}
-
-				assert.Equal(t, cmd, "cmd")
-				assert.Equal(t, args, []string{"/c", "start", "", "https://gitlab.com/peter/calculator/merge_requests/new?merge_request[source_branch]=feature/commit-ui^&merge_request[target_branch]=epic/ui"})
-				return secureexec.Command("echo")
-			},
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://gitlab.com/peter/calculator/merge_requests/new?merge_request[source_branch]=feature/commit-ui&merge_request[target_branch]=epic/ui", url)
-			},
-		},
-		{
-			testName:  "Opens a link to new pull request on gitlab with specific target branch in nested groups",
-			from:      "feature/commit-ui",
-			to:        "epic/ui",
-			remoteUrl: "git@gitlab.com:peter/public/calculator.git",
-			command: func(cmd string, args ...string) *exec.Cmd {
-				// Handle git remote url call
-				if strings.HasPrefix(cmd, "git") {
-					return secureexec.Command("echo", "git@gitlab.com:peter/calculator.git")
-				}
-
-				assert.Equal(t, cmd, "cmd")
-				assert.Equal(t, args, []string{"/c", "start", "", "https://gitlab.com/peter/public/calculator/merge_requests/new?merge_request[source_branch]=feature/commit-ui^&merge_request[target_branch]=epic/ui"})
-				return secureexec.Command("echo")
-			},
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://gitlab.com/peter/public/calculator/merge_requests/new?merge_request[source_branch]=feature/commit-ui&merge_request[target_branch]=epic/ui", url)
-			},
-		},
-		{
-			testName:  "Throws an error if git service is unsupported",
-			from:      "feature/divide-operation",
-			remoteUrl: "git@something.com:peter/calculator.git",
-			command: func(cmd string, args ...string) *exec.Cmd {
-				return secureexec.Command("echo")
-			},
-			test: func(url string, err error) {
-				assert.Error(t, err)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCommand := NewDummyGitCommand()
-			gitCommand.OSCommand.Command = s.command
-			gitCommand.OSCommand.Platform.OS = "windows"
-			gitCommand.OSCommand.Platform.Shell = "cmd"
-			gitCommand.OSCommand.Platform.ShellArg = "/c"
-			gitCommand.OSCommand.Config.GetUserConfig().OS.OpenLinkCommand = `start "" {{link}}`
-			gitCommand.OSCommand.Config.GetUserConfig().Services = map[string]string{
-				// valid configuration for a custom service URL
-				"git.work.com": "gitlab:code.work.com",
-				// invalid configurations for a custom service URL
-				"invalid.work.com":   "noservice:invalid.work.com",
-				"noservice.work.com": "noservice.work.com",
-			}
-			gitCommand.GitConfig = git_config.NewFakeGitConfig(map[string]string{"remote.origin.url": s.remoteUrl})
-			dummyPullRequest := NewPullRequest(gitCommand)
-			s.test(dummyPullRequest.Create(s.from, s.to))
-		})
-	}
-}
@@ -77,8 +77,6 @@ func (c *GitCommand) PrepareInteractiveRebaseCommand(baseSha string, todo string
 	gitSequenceEditor := ex
 	if todo == "" {
 		gitSequenceEditor = "true"
-	} else {
-		c.OSCommand.LogCommand(fmt.Sprintf("Creating TODO file for interactive rebase: \n\n%s", todo), false)
 	}

 	cmd.Env = os.Environ()
@@ -119,7 +117,7 @@ func (c *GitCommand) GenerateGenericRebaseTodo(commits []*models.Commit, actionI
 		var commitAction string
 		if i == actionIndex {
 			commitAction = action
-		} else if commit.IsMerge() {
+		} 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.
@@ -213,7 +211,7 @@ func (c *GitCommand) BeginInteractiveRebaseForCommit(commits []*models.Commit, c
 	// 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() {
+	if c.usingGpg() {
 		return errors.New(c.Tr.DisabledForGPG)
 	}

@@ -1,96 +0,0 @@
-package commands
-
-import (
-	"os/exec"
-	"regexp"
-	"testing"
-
-	"github.com/jesseduffield/lazygit/pkg/test"
-	"github.com/stretchr/testify/assert"
-)
-
-// TestGitCommandRebaseBranch is a function.
-func TestGitCommandRebaseBranch(t *testing.T) {
-	type scenario struct {
-		testName string
-		arg      string
-		command  func(string, ...string) *exec.Cmd
-		test     func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			"successful rebase",
-			"master",
-			test.CreateMockCommand(t, []*test.CommandSwapper{
-				{
-					Expect:  "git rebase --interactive --autostash --keep-empty master",
-					Replace: "echo",
-				},
-			}),
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			"unsuccessful rebase",
-			"master",
-			test.CreateMockCommand(t, []*test.CommandSwapper{
-				{
-					Expect:  "git rebase --interactive --autostash --keep-empty master",
-					Replace: "test",
-				},
-			}),
-			func(err error) {
-				assert.Error(t, err)
-			},
-		},
-	}
-
-	gitCmd := NewDummyGitCommand()
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd.OSCommand.Command = s.command
-			s.test(gitCmd.RebaseBranch(s.arg))
-		})
-	}
-}
-
-// TestGitCommandSkipEditorCommand confirms that SkipEditorCommand injects
-// environment variables that suppress an interactive editor
-func TestGitCommandSkipEditorCommand(t *testing.T) {
-	cmd := NewDummyGitCommand()
-
-	cmd.OSCommand.SetBeforeExecuteCmd(func(cmd *exec.Cmd) {
-		test.AssertContainsMatch(
-			t,
-			cmd.Env,
-			regexp.MustCompile("^VISUAL="),
-			"expected VISUAL to be set for a non-interactive external command",
-		)
-
-		test.AssertContainsMatch(
-			t,
-			cmd.Env,
-			regexp.MustCompile("^EDITOR="),
-			"expected EDITOR to be set for a non-interactive external command",
-		)
-
-		test.AssertContainsMatch(
-			t,
-			cmd.Env,
-			regexp.MustCompile("^GIT_EDITOR="),
-			"expected GIT_EDITOR to be set for a non-interactive external command",
-		)
-
-		test.AssertContainsMatch(
-			t,
-			cmd.Env,
-			regexp.MustCompile("^LAZYGIT_CLIENT_COMMAND=EXIT_IMMEDIATELY$"),
-			"expected LAZYGIT_CLIENT_COMMAND to be set for a non-interactive external command",
-		)
-	})
-
-	_ = cmd.runSkipEditorCommand("true")
-}
@@ -3,40 +3,35 @@ package commands
 import (
 	"fmt"

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

 func (c *GitCommand) AddRemote(name string, url string) error {
-	return c.RunCommand("git remote add %s %s", c.OSCommand.Quote(name), c.OSCommand.Quote(url))
+	return c.OSCommand.RunCommand("git remote add %s %s", name, url)
 }

 func (c *GitCommand) RemoveRemote(name string) error {
-	return c.RunCommand("git remote remove %s", c.OSCommand.Quote(name))
+	return c.OSCommand.RunCommand("git remote remove %s", name)
 }

 func (c *GitCommand) RenameRemote(oldRemoteName string, newRemoteName string) error {
-	return c.RunCommand("git remote rename %s %s", c.OSCommand.Quote(oldRemoteName), c.OSCommand.Quote(newRemoteName))
+	return c.OSCommand.RunCommand("git remote rename %s %s", oldRemoteName, newRemoteName)
 }

 func (c *GitCommand) UpdateRemoteUrl(remoteName string, updatedUrl string) error {
-	return c.RunCommand("git remote set-url %s %s", c.OSCommand.Quote(remoteName), c.OSCommand.Quote(updatedUrl))
+	return c.OSCommand.RunCommand("git remote set-url %s %s", remoteName, updatedUrl)
 }

 func (c *GitCommand) DeleteRemoteBranch(remoteName string, branchName string, promptUserForCredential func(string) string) error {
-	command := fmt.Sprintf("git push %s --delete %s", c.OSCommand.Quote(remoteName), c.OSCommand.Quote(branchName))
-	cmdObj := c.NewCmdObjFromStr(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)
+	command := fmt.Sprintf("git push %s --delete %s", remoteName, branchName)
+	return c.OSCommand.DetectUnamePass(command, promptUserForCredential)
 }

 // CheckRemoteBranchExists Returns remote branch
-func (c *GitCommand) CheckRemoteBranchExists(branchName string) bool {
+func (c *GitCommand) CheckRemoteBranchExists(branch *models.Branch) bool {
 	_, err := c.OSCommand.RunCommandWithOutput(
 		"git show-ref --verify -- refs/remotes/origin/%s",
-		c.OSCommand.Quote(branchName),
+		branch.Name,
 	)

 	return err == nil
@@ -44,5 +39,5 @@ func (c *GitCommand) CheckRemoteBranchExists(branchName string) bool {

 // GetRemoteURL returns current repo remote url
 func (c *GitCommand) GetRemoteURL() string {
-	return c.GitConfig.Get("remote.origin.url")
+	return c.GetConfigValue("remote.origin.url")
 }
@@ -4,13 +4,13 @@ import "fmt"

 // StashDo modify stash
 func (c *GitCommand) StashDo(index int, method string) error {
-	return c.RunCommand("git stash %s stash@{%d}", method, index)
+	return c.OSCommand.RunCommand("git stash %s stash@{%d}", method, index)
 }

 // StashSave save stash
 // TODO: before calling this, check if there is anything to save
 func (c *GitCommand) StashSave(message string) error {
-	return c.RunCommand("git stash save %s", c.OSCommand.Quote(message))
+	return c.OSCommand.RunCommand("git stash save %s", c.OSCommand.Quote(message))
 }

 // GetStashEntryDiff stash diff
@@ -21,8 +21,8 @@ func (c *GitCommand) ShowStashEntryCmdStr(index int) string {
 // 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.RunCommand("git stash --keep-index"); err != nil {
+
+	if err := c.OSCommand.RunCommand("git stash --keep-index"); err != nil {
 		return err
 	}

@@ -30,7 +30,7 @@ func (c *GitCommand) StashSaveStagedChanges(message string) error {
 		return err
 	}

-	if err := c.RunCommand("git stash apply stash@{1}"); err != nil {
+	if err := c.OSCommand.RunCommand("git stash apply stash@{1}"); err != nil {
 		return err
 	}

@@ -38,7 +38,7 @@ func (c *GitCommand) StashSaveStagedChanges(message string) error {
 		return err
 	}

-	if err := c.RunCommand("git stash drop stash@{1}"); err != nil {
+	if err := c.OSCommand.RunCommand("git stash drop stash@{1}"); err != nil {
 		return err
 	}

@@ -48,7 +48,7 @@ func (c *GitCommand) StashSaveStagedChanges(message string) error {
 	files := c.GetStatusFiles(GetStatusFileOptions{})
 	for _, file := range files {
 		if file.ShortStatus == "AD" {
-			if err := c.UnStageFile(file.Names(), false); err != nil {
+			if err := c.UnStageFile(file.Name, false); err != nil {
 				return err
 			}
 		}
@@ -1,35 +0,0 @@
-package commands
-
-import (
-	"os/exec"
-	"testing"
-
-	"github.com/jesseduffield/lazygit/pkg/secureexec"
-	"github.com/stretchr/testify/assert"
-)
-
-// TestGitCommandStashDo is a function.
-func TestGitCommandStashDo(t *testing.T) {
-	gitCmd := NewDummyGitCommand()
-	gitCmd.OSCommand.Command = func(cmd string, args ...string) *exec.Cmd {
-		assert.EqualValues(t, "git", cmd)
-		assert.EqualValues(t, []string{"stash", "drop", "stash@{1}"}, args)
-
-		return secureexec.Command("echo")
-	}
-
-	assert.NoError(t, gitCmd.StashDo(1, "drop"))
-}
-
-// TestGitCommandStashSave is a function.
-func TestGitCommandStashSave(t *testing.T) {
-	gitCmd := NewDummyGitCommand()
-	gitCmd.OSCommand.Command = func(cmd string, args ...string) *exec.Cmd {
-		assert.EqualValues(t, "git", cmd)
-		assert.EqualValues(t, []string{"stash", "save", "A stash message"}, args)
-
-		return secureexec.Command("echo")
-	}
-
-	assert.NoError(t, gitCmd.StashSave("A stash message"))
-}
@@ -6,13 +6,6 @@ import (
 	gogit "github.com/jesseduffield/go-git/v5"
 )

-const (
-	REBASE_MODE_NORMAL      = "normal"
-	REBASE_MODE_INTERACTIVE = "interactive"
-	REBASE_MODE_REBASING    = "rebasing"
-	REBASE_MODE_MERGING     = "merging"
-)
-
 // RebaseMode returns "" for non-rebase mode, "normal" for normal rebase
 // and "interactive" for interactive rebase
 func (c *GitCommand) RebaseMode() (string, error) {
@@ -21,11 +14,11 @@ func (c *GitCommand) RebaseMode() (string, error) {
 		return "", err
 	}
 	if exists {
-		return REBASE_MODE_NORMAL, nil
+		return "normal", nil
 	}
 	exists, err = c.OSCommand.FileExists(filepath.Join(c.DotGitDir, "rebase-merge"))
 	if exists {
-		return REBASE_MODE_INTERACTIVE, err
+		return "interactive", err
 	} else {
 		return "", err
 	}
@@ -34,13 +27,13 @@ func (c *GitCommand) RebaseMode() (string, error) {
 func (c *GitCommand) WorkingTreeState() string {
 	rebaseMode, _ := c.RebaseMode()
 	if rebaseMode != "" {
-		return REBASE_MODE_REBASING
+		return "rebasing"
 	}
 	merging, _ := c.IsInMergeState()
 	if merging {
-		return REBASE_MODE_MERGING
+		return "merging"
 	}
-	return REBASE_MODE_NORMAL
+	return "normal"
 }

 // IsInMergeState states whether we are still mid-merge
@@ -69,28 +69,28 @@ func (c *GitCommand) SubmoduleStash(submodule *models.SubmoduleConfig) error {
 		return nil
 	}

-	return c.RunCommand("git -C %s stash --include-untracked", c.OSCommand.Quote(submodule.Path))
+	return c.OSCommand.RunCommand("git -C %s stash --include-untracked", submodule.Path)
 }

 func (c *GitCommand) SubmoduleReset(submodule *models.SubmoduleConfig) error {
-	return c.RunCommand("git submodule update --init --force -- %s", c.OSCommand.Quote(submodule.Path))
+	return c.OSCommand.RunCommand("git submodule update --init --force %s", submodule.Path)
 }

 func (c *GitCommand) SubmoduleUpdateAll() error {
 	// not doing an --init here because the user probably doesn't want that
-	return c.RunCommand("git submodule update --force")
+	return c.OSCommand.RunCommand("git submodule update --force")
 }

 func (c *GitCommand) SubmoduleDelete(submodule *models.SubmoduleConfig) error {
 	// based on https://gist.github.com/myusuf3/7f645819ded92bda6677

-	if err := c.RunCommand("git submodule deinit --force -- %s", c.OSCommand.Quote(submodule.Path)); err != nil {
+	if err := c.OSCommand.RunCommand("git submodule deinit --force %s", submodule.Path); err != nil {
 		if strings.Contains(err.Error(), "did not match any file(s) known to git") {
-			if err := c.RunCommand("git config --file .gitmodules --remove-section submodule.%s", c.OSCommand.Quote(submodule.Name)); err != nil {
+			if err := c.OSCommand.RunCommand("git config --file .gitmodules --remove-section submodule.%s", submodule.Name); err != nil {
 				return err
 			}

-			if err := c.RunCommand("git config --remove-section submodule.%s", c.OSCommand.Quote(submodule.Name)); err != nil {
+			if err := c.OSCommand.RunCommand("git config --remove-section submodule.%s", submodule.Name); err != nil {
 				return err
 			}

@@ -100,7 +100,7 @@ func (c *GitCommand) SubmoduleDelete(submodule *models.SubmoduleConfig) error {
 		}
 	}

-	if err := c.RunCommand("git rm --force -r %s", submodule.Path); err != nil {
+	if err := c.OSCommand.RunCommand("git rm --force -r %s", submodule.Path); err != nil {
 		// if the directory isn't there then that's fine
 		c.Log.Error(err)
 	}
@@ -119,11 +119,11 @@ func (c *GitCommand) SubmoduleAdd(name string, path string, url string) error {

 func (c *GitCommand) SubmoduleUpdateUrl(name string, path string, newUrl string) error {
 	// the set-url command is only for later git versions so we're doing it manually here
-	if err := c.RunCommand("git config --file .gitmodules submodule.%s.url %s", c.OSCommand.Quote(name), c.OSCommand.Quote(newUrl)); err != nil {
+	if err := c.OSCommand.RunCommand("git config --file .gitmodules submodule.%s.url %s", name, newUrl); err != nil {
 		return err
 	}

-	if err := c.RunCommand("git submodule sync -- %s", c.OSCommand.Quote(path)); err != nil {
+	if err := c.OSCommand.RunCommand("git submodule sync %s", path); err != nil {
 		return err
 	}

@@ -131,11 +131,11 @@ func (c *GitCommand) SubmoduleUpdateUrl(name string, path string, newUrl string)
 }

 func (c *GitCommand) SubmoduleInit(path string) error {
-	return c.RunCommand("git submodule init -- %s", c.OSCommand.Quote(path))
+	return c.OSCommand.RunCommand("git submodule init %s", path)
 }

 func (c *GitCommand) SubmoduleUpdate(path string) error {
-	return c.RunCommand("git submodule update --init -- %s", c.OSCommand.Quote(path))
+	return c.OSCommand.RunCommand("git submodule update --init %s", path)
 }

 func (c *GitCommand) SubmoduleBulkInitCmdStr() string {
@@ -2,43 +2,40 @@ package commands

 import (
 	"fmt"
-
-	"github.com/go-errors/errors"
+	"strings"
 )

-// Push pushes to a branch
-type PushOpts struct {
-	Force                   bool
-	UpstreamRemote          string
-	UpstreamBranch          string
-	SetUpstream             bool
-	PromptUserForCredential func(string) string
+// 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.Config.GetUserConfig().Git.OverrideGpg
+	if overrideGpg {
+		return false
+	}
+
+	gpgsign, _ := c.getLocalGitConfig("commit.gpgsign")
+	if gpgsign == "" {
+		gpgsign, _ = c.getGlobalGitConfig("commit.gpgsign")
+	}
+	value := strings.ToLower(gpgsign)
+
+	return value == "true" || value == "1" || value == "yes" || value == "on"
 }

-func (c *GitCommand) Push(opts PushOpts) error {
-	cmdStr := "git push"
-
-	if opts.Force {
-		cmdStr += " --force-with-lease"
+// Push pushes to a branch
+func (c *GitCommand) Push(branchName string, force bool, upstream string, args string, promptUserForCredential func(string) string) error {
+	forceFlag := ""
+	if force {
+		forceFlag = "--force-with-lease"
 	}

-	if opts.SetUpstream {
-		cmdStr += " --set-upstream"
+	setUpstreamArg := ""
+	if upstream != "" {
+		setUpstreamArg = "--set-upstream " + upstream
 	}

-	if opts.UpstreamRemote != "" {
-		cmdStr += " " + c.OSCommand.Quote(opts.UpstreamRemote)
-	}
-
-	if opts.UpstreamBranch != "" {
-		if opts.UpstreamRemote == "" {
-			return errors.New(c.Tr.MustSpecifyOriginError)
-		}
-		cmdStr += " " + c.OSCommand.Quote(opts.UpstreamBranch)
-	}
-
-	cmdObj := c.NewCmdObjFromStr(cmdStr)
-	return c.DetectUnamePass(cmdObj, opts.PromptUserForCredential)
+	cmd := fmt.Sprintf("git push --follow-tags %s %s %s", forceFlag, setUpstreamArg, args)
+	return c.OSCommand.DetectUnamePass(cmd, promptUserForCredential)
 }

 type FetchOptions struct {
@@ -49,17 +46,16 @@ type FetchOptions struct {

 // Fetch fetch git repo
 func (c *GitCommand) Fetch(opts FetchOptions) error {
-	cmdStr := "git fetch"
+	command := "git fetch"

 	if opts.RemoteName != "" {
-		cmdStr = fmt.Sprintf("%s %s", cmdStr, c.OSCommand.Quote(opts.RemoteName))
+		command = fmt.Sprintf("%s %s", command, opts.RemoteName)
 	}
 	if opts.BranchName != "" {
-		cmdStr = fmt.Sprintf("%s %s", cmdStr, c.OSCommand.Quote(opts.BranchName))
+		command = fmt.Sprintf("%s %s", command, opts.BranchName)
 	}

-	cmdObj := c.NewCmdObjFromStr(cmdStr)
-	return c.DetectUnamePass(cmdObj, func(question string) string {
+	return c.OSCommand.DetectUnamePass(command, func(question string) string {
 		if opts.PromptUserForCredential != nil {
 			return opts.PromptUserForCredential(question)
 		}
@@ -67,45 +63,12 @@ func (c *GitCommand) Fetch(opts FetchOptions) error {
 	})
 }

-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.NewCmdObjFromStr(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.NewCmdObjFromStr(cmdStr)
-	return c.DetectUnamePass(cmdObj, promptUserForCredential)
+	command := fmt.Sprintf("git fetch %s %s:%s", remoteName, remoteBranchName, branchName)
+	return c.OSCommand.DetectUnamePass(command, promptUserForCredential)
 }

 func (c *GitCommand) FetchRemote(remoteName string, promptUserForCredential func(string) string) error {
-	cmdStr := fmt.Sprintf("git fetch %s", c.OSCommand.Quote(remoteName))
-	cmdObj := c.NewCmdObjFromStr(cmdStr)
-	return c.DetectUnamePass(cmdObj, promptUserForCredential)
+	command := fmt.Sprintf("git fetch %s", remoteName)
+	return c.OSCommand.DetectUnamePass(command, promptUserForCredential)
 }
@@ -1,164 +0,0 @@
-package commands
-
-import (
-	"os/exec"
-	"testing"
-
-	"github.com/jesseduffield/lazygit/pkg/secureexec"
-	"github.com/stretchr/testify/assert"
-)
-
-// TestGitCommandPush is a function.
-func TestGitCommandPush(t *testing.T) {
-	type scenario struct {
-		testName string
-		command  func(string, ...string) *exec.Cmd
-		opts     PushOpts
-		test     func(error)
-	}
-
-	prompt := func(passOrUname string) string {
-		return "\n"
-	}
-
-	scenarios := []scenario{
-		{
-			"Push with force disabled",
-			func(cmd string, args ...string) *exec.Cmd {
-				assert.EqualValues(t, "git", cmd)
-				assert.EqualValues(t, []string{"push"}, args)
-
-				return secureexec.Command("echo")
-			},
-			PushOpts{Force: false, PromptUserForCredential: prompt},
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			"Push with force enabled",
-			func(cmd string, args ...string) *exec.Cmd {
-				assert.EqualValues(t, "git", cmd)
-				assert.EqualValues(t, []string{"push", "--force-with-lease"}, args)
-
-				return secureexec.Command("echo")
-			},
-			PushOpts{Force: true, PromptUserForCredential: prompt},
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			"Push with an error occurring",
-			func(cmd string, args ...string) *exec.Cmd {
-				assert.EqualValues(t, "git", cmd)
-				assert.EqualValues(t, []string{"push"}, args)
-				return secureexec.Command("test")
-			},
-			PushOpts{Force: false, PromptUserForCredential: prompt},
-			func(err error) {
-				assert.Error(t, err)
-			},
-		},
-		{
-			"Push with force disabled, upstream supplied",
-			func(cmd string, args ...string) *exec.Cmd {
-				assert.EqualValues(t, "git", cmd)
-				assert.EqualValues(t, []string{"push", "origin", "master"}, args)
-
-				return secureexec.Command("echo")
-			},
-			PushOpts{
-				Force:                   false,
-				UpstreamRemote:          "origin",
-				UpstreamBranch:          "master",
-				PromptUserForCredential: prompt,
-			},
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			"Push with force disabled, setting upstream",
-			func(cmd string, args ...string) *exec.Cmd {
-				assert.EqualValues(t, "git", cmd)
-				assert.EqualValues(t, []string{"push", "--set-upstream", "origin", "master"}, args)
-
-				return secureexec.Command("echo")
-			},
-			PushOpts{
-				Force:                   false,
-				UpstreamRemote:          "origin",
-				UpstreamBranch:          "master",
-				PromptUserForCredential: prompt,
-				SetUpstream:             true,
-			},
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			"Push with force enabled, setting upstream",
-			func(cmd string, args ...string) *exec.Cmd {
-				assert.EqualValues(t, "git", cmd)
-				assert.EqualValues(t, []string{"push", "--force-with-lease", "--set-upstream", "origin", "master"}, args)
-
-				return secureexec.Command("echo")
-			},
-			PushOpts{
-				Force:                   true,
-				UpstreamRemote:          "origin",
-				UpstreamBranch:          "master",
-				PromptUserForCredential: prompt,
-				SetUpstream:             true,
-			},
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			"Push with remote branch but no origin",
-			func(cmd string, args ...string) *exec.Cmd {
-				return nil
-			},
-			PushOpts{
-				Force:                   true,
-				UpstreamRemote:          "",
-				UpstreamBranch:          "master",
-				PromptUserForCredential: prompt,
-				SetUpstream:             true,
-			},
-			func(err error) {
-				assert.Error(t, err)
-				assert.EqualValues(t, "Must specify a remote if specifying a branch", err.Error())
-			},
-		},
-		{
-			"Push with force disabled, upstream supplied",
-			func(cmd string, args ...string) *exec.Cmd {
-				assert.EqualValues(t, "git", cmd)
-				assert.EqualValues(t, []string{"push", "origin", "master"}, args)
-
-				return secureexec.Command("echo")
-			},
-			PushOpts{
-				Force:                   false,
-				UpstreamRemote:          "origin",
-				UpstreamBranch:          "master",
-				PromptUserForCredential: prompt,
-			},
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommand()
-			gitCmd.OSCommand.Command = s.command
-			err := gitCmd.Push(s.opts)
-			s.test(err)
-		})
-	}
-}
@@ -1,19 +1,16 @@
 package commands

-import (
-	"fmt"
-)
+import "fmt"

 func (c *GitCommand) CreateLightweightTag(tagName string, commitSha string) error {
-	return c.RunCommand("git tag -- %s %s", c.OSCommand.Quote(tagName), commitSha)
+	return c.OSCommand.RunCommand("git tag %s %s", tagName, commitSha)
 }

 func (c *GitCommand) DeleteTag(tagName string) error {
-	return c.RunCommand("git tag -d %s", c.OSCommand.Quote(tagName))
+	return c.OSCommand.RunCommand("git tag -d %s", tagName)
 }

 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.NewCmdObjFromStr(cmdStr)
-	return c.DetectUnamePass(cmdObj, promptUserForCredential)
+	command := fmt.Sprintf("git push %s %s", remoteName, tagName)
+	return c.OSCommand.DetectUnamePass(command, promptUserForCredential)
 }
@@ -12,19 +12,17 @@ import (

 // AppConfig contains the base configuration fields required for lazygit.
 type AppConfig struct {
-	Debug            bool   `long:"debug" env:"DEBUG" default:"false"`
-	Version          string `long:"version" env:"VERSION" default:"unversioned"`
-	Commit           string `long:"commit" env:"COMMIT"`
-	BuildDate        string `long:"build-date" env:"BUILD_DATE"`
-	Name             string `long:"name" env:"NAME" default:"lazygit"`
-	BuildSource      string `long:"build-source" env:"BUILD_SOURCE" default:""`
-	UserConfig       *UserConfig
-	UserConfigPaths  []string
-	DeafultConfFiles bool
-	UserConfigDir    string
-	TempDir          string
-	AppState         *AppState
-	IsNewRepo        bool
+	Debug          bool   `long:"debug" env:"DEBUG" default:"false"`
+	Version        string `long:"version" env:"VERSION" default:"unversioned"`
+	Commit         string `long:"commit" env:"COMMIT"`
+	BuildDate      string `long:"build-date" env:"BUILD_DATE"`
+	Name           string `long:"name" env:"NAME" default:"lazygit"`
+	BuildSource    string `long:"build-source" env:"BUILD_SOURCE" default:""`
+	UserConfig     *UserConfig
+	UserConfigDir  string
+	UserConfigPath string
+	AppState       *AppState
+	IsNewRepo      bool
 }

 // AppConfigurer interface allows individual app config structs to inherit Fields
@@ -37,35 +35,22 @@ type AppConfigurer interface {
 	GetName() string
 	GetBuildSource() string
 	GetUserConfig() *UserConfig
-	GetUserConfigPaths() []string
 	GetUserConfigDir() string
-	GetTempDir() string
+	GetUserConfigPath() string
 	GetAppState() *AppState
 	SaveAppState() error
 	SetIsNewRepo(bool)
 	GetIsNewRepo() bool
-	ReloadUserConfig() error
-	ShowCommandLogOnStartup() bool
 }

 // NewAppConfig makes a new app config
 func NewAppConfig(name, version, commit, date string, buildSource string, debuggingFlag bool) (*AppConfig, error) {
 	configDir, err := findOrCreateConfigDir()
-	if err != nil && !os.IsPermission(err) {
+	if err != nil {
 		return nil, err
 	}

-	var userConfigPaths []string
-	customConfigFiles := os.Getenv("LG_CONFIG_FILE")
-	if customConfigFiles != "" {
-		// Load user defined config files
-		userConfigPaths = strings.Split(customConfigFiles, ",")
-	} else {
-		// Load default config files
-		userConfigPaths = []string{filepath.Join(configDir, ConfigFilename)}
-	}
-
-	userConfig, err := loadUserConfigWithDefaults(userConfigPaths)
+	userConfig, err := loadUserConfigWithDefaults(configDir)
 	if err != nil {
 		return nil, err
 	}
@@ -74,94 +59,80 @@ func NewAppConfig(name, version, commit, date string, buildSource string, debugg
 		debuggingFlag = true
 	}

-	tempDir := filepath.Join(os.TempDir(), "lazygit")
-
 	appState, err := loadAppState()
 	if err != nil {
 		return nil, err
 	}

 	appConfig := &AppConfig{
-		Name:            "lazygit",
-		Version:         version,
-		Commit:          commit,
-		BuildDate:       date,
-		Debug:           debuggingFlag,
-		BuildSource:     buildSource,
-		UserConfig:      userConfig,
-		UserConfigPaths: userConfigPaths,
-		UserConfigDir:   configDir,
-		TempDir:         tempDir,
-		AppState:        appState,
-		IsNewRepo:       false,
+		Name:           "lazygit",
+		Version:        version,
+		Commit:         commit,
+		BuildDate:      date,
+		Debug:          debuggingFlag,
+		BuildSource:    buildSource,
+		UserConfig:     userConfig,
+		UserConfigDir:  configDir,
+		UserConfigPath: filepath.Join(configDir, "config.yml"),
+		AppState:       appState,
+		IsNewRepo:      false,
 	}

 	return appConfig, nil
 }

-func isCustomConfigFile(path string) bool {
-	return path != filepath.Join(ConfigDir(), ConfigFilename)
-}
-
 func ConfigDir() string {
-	legacyConfigDirectory := configDirForVendor("jesseduffield")
-	if _, err := os.Stat(legacyConfigDirectory); !os.IsNotExist(err) {
-		return legacyConfigDirectory
-	}
-	configDirectory := configDirForVendor("")
-	return configDirectory
-}
-
-func configDirForVendor(vendor string) string {
 	envConfigDir := os.Getenv("CONFIG_DIR")
 	if envConfigDir != "" {
 		return envConfigDir
 	}
-	configDirs := xdg.New(vendor, "lazygit")
+
+	// chucking my name there is not for vanity purposes, the xdg spec (and that
+	// function) requires a vendor name. May as well line up with github
+	configDirs := xdg.New("jesseduffield", "lazygit")
 	return configDirs.ConfigHome()
 }

 func findOrCreateConfigDir() (string, error) {
 	folder := ConfigDir()
-	return folder, os.MkdirAll(folder, 0755)
+
+	err := os.MkdirAll(folder, 0755)
+	if err != nil {
+		return "", err
+	}
+
+	return folder, nil
 }

-func loadUserConfigWithDefaults(configFiles []string) (*UserConfig, error) {
-	return loadUserConfig(configFiles, GetDefaultConfig())
+func loadUserConfigWithDefaults(configDir string) (*UserConfig, error) {
+	return loadUserConfig(configDir, GetDefaultConfig())
 }

-func loadUserConfig(configFiles []string, base *UserConfig) (*UserConfig, error) {
-	for _, path := range configFiles {
-		if _, err := os.Stat(path); err != nil {
-			if !os.IsNotExist(err) {
-				return nil, err
-			}
+func loadUserConfig(configDir string, base *UserConfig) (*UserConfig, error) {
+	fileName := filepath.Join(configDir, "config.yml")

-			// if use has supplied their own custom config file path(s), we assume
-			// the files have already been created, so we won't go and create them here.
-			if isCustomConfigFile(path) {
-				return nil, err
-			}
-
-			file, err := os.Create(path)
+	if _, err := os.Stat(fileName); err != nil {
+		if os.IsNotExist(err) {
+			file, err := os.Create(fileName)
 			if err != nil {
-				if os.IsPermission(err) {
-					// apparently when people have read-only permissions they prefer us to fail silently
-					continue
+				if strings.Contains(err.Error(), "read-only file system") {
+					return base, nil
 				}
 				return nil, err
 			}
 			file.Close()
-		}
-
-		content, err := ioutil.ReadFile(path)
-		if err != nil {
+		} else {
 			return nil, err
 		}
+	}

-		if err := yaml.Unmarshal(content, base); err != nil {
-			return nil, err
-		}
+	content, err := ioutil.ReadFile(fileName)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := yaml.Unmarshal(content, base); err != nil {
+		return nil, err
 	}

 	return base, nil
@@ -213,33 +184,20 @@ func (c *AppConfig) GetUserConfig() *UserConfig {
 	return c.UserConfig
 }

+// GetUserConfig returns the user config
+func (c *AppConfig) GetUserConfigPath() string {
+	return c.UserConfigPath
+}
+
 // GetAppState returns the app state
 func (c *AppConfig) GetAppState() *AppState {
 	return c.AppState
 }

-func (c *AppConfig) GetUserConfigPaths() []string {
-	return c.UserConfigPaths
-}
-
 func (c *AppConfig) GetUserConfigDir() string {
 	return c.UserConfigDir
 }

-func (c *AppConfig) GetTempDir() string {
-	return c.TempDir
-}
-
-func (c *AppConfig) ReloadUserConfig() error {
-	userConfig, err := loadUserConfigWithDefaults(c.UserConfigPaths)
-	if err != nil {
-		return err
-	}
-
-	c.UserConfig = userConfig
-	return nil
-}
-
 func configFilePath(filename string) (string, error) {
 	folder, err := findOrCreateConfigDir()
 	if err != nil {
@@ -249,11 +207,9 @@ func configFilePath(filename string) (string, error) {
 	return filepath.Join(folder, filename), nil
 }

-var ConfigFilename = "config.yml"
-
-// ConfigFilename returns the filename of the deafult config file
+// ConfigFilename returns the filename of the current config file
 func (c *AppConfig) ConfigFilename() string {
-	return filepath.Join(c.UserConfigDir, ConfigFilename)
+	return filepath.Join(c.UserConfigDir, "config.yml")
 }

 // SaveAppState marshalls the AppState struct and writes it to the disk
@@ -268,34 +224,13 @@ func (c *AppConfig) SaveAppState() error {
 		return err
 	}

-	err = ioutil.WriteFile(filepath, marshalledAppState, 0644)
-	if err != nil && os.IsPermission(err) {
-		// apparently when people have read-only permissions they prefer us to fail silently
-		return nil
-	}
-
-	return err
-}
-
-// originally we could only hide the command log permanently via the config
-// but now we do it via state. So we need to still support the config for the
-// sake of backwards compatibility
-func (c *AppConfig) ShowCommandLogOnStartup() bool {
-	if !c.UserConfig.Gui.ShowCommandLog {
-		return false
-	}
-
-	return !c.AppState.HideCommandLog
+	return ioutil.WriteFile(filepath, marshalledAppState, 0644)
 }

 // loadAppState loads recorded AppState from file
 func loadAppState() (*AppState, error) {
 	filepath, err := configFilePath("state.yml")
 	if err != nil {
-		if os.IsPermission(err) {
-			// apparently when people have read-only permissions they prefer us to fail silently
-			return getDefaultAppState(), nil
-		}
 		return nil, err
 	}

@@ -323,10 +258,6 @@ type AppState struct {
 	LastUpdateCheck     int64
 	RecentRepos         []string
 	StartupPopupVersion int
-
-	// these are for custom commands typed in directly, not for custom commands in the lazygit config
-	CustomCommandsHistory []string
-	HideCommandLog        bool
 }

 func getDefaultAppState() *AppState {
@@ -1,4 +1,3 @@
-//go:build !windows && !linux
 // +build !windows,!linux

 package config
@@ -6,9 +5,7 @@ package config
 // GetPlatformDefaultConfig gets the defaults for the platform
 func GetPlatformDefaultConfig() OSConfig {
 	return OSConfig{
-		EditCommand:         ``,
-		EditCommandTemplate: `{{editor}} {{filename}}`,
-		OpenCommand:         "open {{filename}}",
-		OpenLinkCommand:     "open {{link}}",
+		OpenCommand:     "open {{filename}}",
+		OpenLinkCommand: "open {{link}}",
 	}
 }
@@ -3,9 +3,7 @@ package config
 // GetPlatformDefaultConfig gets the defaults for the platform
 func GetPlatformDefaultConfig() OSConfig {
 	return OSConfig{
-		EditCommand:         ``,
-		EditCommandTemplate: `{{editor}} {{filename}}`,
-		OpenCommand:         `xdg-open {{filename}} >/dev/null`,
-		OpenLinkCommand:     `xdg-open {{link}} >/dev/null`,
+		OpenCommand:     `sh -c "xdg-open {{filename}} >/dev/null"`,
+		OpenLinkCommand: `sh -c "xdg-open {{link}} >/dev/null"`,
 	}
 }
@@ -3,9 +3,7 @@ package config
 // GetPlatformDefaultConfig gets the defaults for the platform
 func GetPlatformDefaultConfig() OSConfig {
 	return OSConfig{
-		EditCommand:         ``,
-		EditCommandTemplate: `{{editor}} {{filename}}`,
-		OpenCommand:         `start "" {{filename}}`,
-		OpenLinkCommand:     `start "" {{link}}`,
+		OpenCommand:     `cmd /c "start "" {{filename}}"`,
+		OpenLinkCommand: `cmd /c "start "" {{link}}"`,
 	}
 }
@@ -14,7 +14,6 @@ func NewDummyAppConfig() *AppConfig {
 		Debug:       false,
 		BuildSource: "",
 		UserConfig:  GetDefaultConfig(),
-		AppState:    &AppState{},
 	}
 	_ = yaml.Unmarshal([]byte{}, appConfig.AppState)
 	return appConfig
@@ -4,7 +4,6 @@ type UserConfig struct {
 	Gui                  GuiConfig        `yaml:"gui"`
 	Git                  GitConfig        `yaml:"git"`
 	Update               UpdateConfig     `yaml:"update"`
-	Refresher            RefresherConfig  `yaml:"refresher"`
 	Reporting            string           `yaml:"reporting"`
 	SplashUpdatesIndex   int              `yaml:"splashUpdatesIndex"`
 	ConfirmOnQuit        bool             `yaml:"confirmOnQuit"`
@@ -15,44 +14,28 @@ type UserConfig struct {
 	DisableStartupPopups bool              `yaml:"disableStartupPopups"`
 	CustomCommands       []CustomCommand   `yaml:"customCommands"`
 	Services             map[string]string `yaml:"services"`
-	NotARepository       string            `yaml:"notARepository"`
-}
-
-type RefresherConfig struct {
-	RefreshInterval int `yaml:"refreshInterval"`
-	FetchInterval   int `yaml:"fetchInterval"`
 }

 type GuiConfig struct {
-	AuthorColors             map[string]string  `yaml:"authorColors"`
-	ScrollHeight             int                `yaml:"scrollHeight"`
-	ScrollPastBottom         bool               `yaml:"scrollPastBottom"`
-	MouseEvents              bool               `yaml:"mouseEvents"`
-	SkipUnstageLineWarning   bool               `yaml:"skipUnstageLineWarning"`
-	SkipStashWarning         bool               `yaml:"skipStashWarning"`
-	SidePanelWidth           float64            `yaml:"sidePanelWidth"`
-	ExpandFocusedSidePanel   bool               `yaml:"expandFocusedSidePanel"`
-	MainPanelSplitMode       string             `yaml:"mainPanelSplitMode"`
-	Language                 string             `yaml:"language"`
-	Theme                    ThemeConfig        `yaml:"theme"`
-	CommitLength             CommitLengthConfig `yaml:"commitLength"`
-	SkipNoStagedFilesWarning bool               `yaml:"skipNoStagedFilesWarning"`
-	ShowListFooter           bool               `yaml:"showListFooter"`
-	ShowFileTree             bool               `yaml:"showFileTree"`
-	ShowRandomTip            bool               `yaml:"showRandomTip"`
-	ShowCommandLog           bool               `yaml:"showCommandLog"`
-	CommandLogSize           int                `yaml:"commandLogSize"`
+	ScrollHeight           int                `yaml:"scrollHeight"`
+	ScrollPastBottom       bool               `yaml:"scrollPastBottom"`
+	MouseEvents            bool               `yaml:"mouseEvents"`
+	SkipUnstageLineWarning bool               `yaml:"skipUnstageLineWarning"`
+	SkipStashWarning       bool               `yaml:"skipStashWarning"`
+	SidePanelWidth         float64            `yaml:"sidePanelWidth"`
+	ExpandFocusedSidePanel bool               `yaml:"expandFocusedSidePanel"`
+	MainPanelSplitMode     string             `yaml:"mainPanelSplitMode"`
+	Theme                  ThemeConfig        `yaml:"theme"`
+	CommitLength           CommitLengthConfig `yaml:"commitLength"`
 }

 type ThemeConfig struct {
-	LightTheme                bool     `yaml:"lightTheme"`
-	ActiveBorderColor         []string `yaml:"activeBorderColor"`
-	InactiveBorderColor       []string `yaml:"inactiveBorderColor"`
-	OptionsTextColor          []string `yaml:"optionsTextColor"`
-	SelectedLineBgColor       []string `yaml:"selectedLineBgColor"`
-	SelectedRangeBgColor      []string `yaml:"selectedRangeBgColor"`
-	CherryPickedCommitBgColor []string `yaml:"cherryPickedCommitBgColor"`
-	CherryPickedCommitFgColor []string `yaml:"cherryPickedCommitFgColor"`
+	LightTheme           bool     `yaml:"lightTheme"`
+	ActiveBorderColor    []string `yaml:"activeBorderColor"`
+	InactiveBorderColor  []string `yaml:"inactiveBorderColor"`
+	OptionsTextColor     []string `yaml:"optionsTextColor"`
+	SelectedLineBgColor  []string `yaml:"selectedLineBgColor"`
+	SelectedRangeBgColor []string `yaml:"selectedRangeBgColor"`
 }

 type CommitLengthConfig struct {
@@ -62,16 +45,13 @@ type CommitLengthConfig struct {
 type GitConfig struct {
 	Paging              PagingConfig                  `yaml:"paging"`
 	Merging             MergingConfig                 `yaml:"merging"`
+	Pull                PullConfig                    `yaml:"pull"`
 	SkipHookPrefix      string                        `yaml:"skipHookPrefix"`
 	AutoFetch           bool                          `yaml:"autoFetch"`
 	BranchLogCmd        string                        `yaml:"branchLogCmd"`
-	AllBranchesLogCmd   string                        `yaml:"allBranchesLogCmd"`
 	OverrideGpg         bool                          `yaml:"overrideGpg"`
 	DisableForcePushing bool                          `yaml:"disableForcePushing"`
 	CommitPrefixes      map[string]CommitPrefixConfig `yaml:"commitPrefixes"`
-	// this shoudl really be under 'gui', not 'git'
-	ParseEmoji bool      `yaml:"parseEmoji"`
-	Log        LogConfig `yaml:"log"`
 }

 type PagingConfig struct {
@@ -85,9 +65,8 @@ type MergingConfig struct {
 	Args         string `yaml:"args"`
 }

-type LogConfig struct {
-	Order     string `yaml:"order"`     // one of date-order, author-date-order, topo-order
-	ShowGraph string `yaml:"showGraph"` // one of always, never, when-maximised
+type PullConfig struct {
+	Mode string `yaml:"mode"`
 }

 type CommitPrefixConfig struct {
@@ -112,76 +91,66 @@ type KeybindingConfig struct {
 	Submodules  KeybindingSubmodulesConfig  `yaml:"submodules"`
 }

-// damn looks like we have some inconsistencies here with -alt and -alt1
 type KeybindingUniversalConfig struct {
-	Quit                         string   `yaml:"quit"`
-	QuitAlt1                     string   `yaml:"quit-alt1"`
-	Return                       string   `yaml:"return"`
-	QuitWithoutChangingDirectory string   `yaml:"quitWithoutChangingDirectory"`
-	TogglePanel                  string   `yaml:"togglePanel"`
-	PrevItem                     string   `yaml:"prevItem"`
-	NextItem                     string   `yaml:"nextItem"`
-	PrevItemAlt                  string   `yaml:"prevItem-alt"`
-	NextItemAlt                  string   `yaml:"nextItem-alt"`
-	PrevPage                     string   `yaml:"prevPage"`
-	NextPage                     string   `yaml:"nextPage"`
-	ScrollLeft                   string   `yaml:"scrollLeft"`
-	ScrollRight                  string   `yaml:"scrollRight"`
-	GotoTop                      string   `yaml:"gotoTop"`
-	GotoBottom                   string   `yaml:"gotoBottom"`
-	PrevBlock                    string   `yaml:"prevBlock"`
-	NextBlock                    string   `yaml:"nextBlock"`
-	PrevBlockAlt                 string   `yaml:"prevBlock-alt"`
-	NextBlockAlt                 string   `yaml:"nextBlock-alt"`
-	NextBlockAlt2                string   `yaml:"nextBlock-alt2"`
-	PrevBlockAlt2                string   `yaml:"prevBlock-alt2"`
-	JumpToBlock                  []string `yaml:"jumpToBlock"`
-	NextMatch                    string   `yaml:"nextMatch"`
-	PrevMatch                    string   `yaml:"prevMatch"`
-	StartSearch                  string   `yaml:"startSearch"`
-	OptionMenu                   string   `yaml:"optionMenu"`
-	OptionMenuAlt1               string   `yaml:"optionMenu-alt1"`
-	Select                       string   `yaml:"select"`
-	GoInto                       string   `yaml:"goInto"`
-	Confirm                      string   `yaml:"confirm"`
-	ConfirmAlt1                  string   `yaml:"confirm-alt1"`
-	Remove                       string   `yaml:"remove"`
-	New                          string   `yaml:"new"`
-	Edit                         string   `yaml:"edit"`
-	OpenFile                     string   `yaml:"openFile"`
-	ScrollUpMain                 string   `yaml:"scrollUpMain"`
-	ScrollDownMain               string   `yaml:"scrollDownMain"`
-	ScrollUpMainAlt1             string   `yaml:"scrollUpMain-alt1"`
-	ScrollDownMainAlt1           string   `yaml:"scrollDownMain-alt1"`
-	ScrollUpMainAlt2             string   `yaml:"scrollUpMain-alt2"`
-	ScrollDownMainAlt2           string   `yaml:"scrollDownMain-alt2"`
-	ExecuteCustomCommand         string   `yaml:"executeCustomCommand"`
-	CreateRebaseOptionsMenu      string   `yaml:"createRebaseOptionsMenu"`
-	PushFiles                    string   `yaml:"pushFiles"`
-	PullFiles                    string   `yaml:"pullFiles"`
-	Refresh                      string   `yaml:"refresh"`
-	CreatePatchOptionsMenu       string   `yaml:"createPatchOptionsMenu"`
-	NextTab                      string   `yaml:"nextTab"`
-	PrevTab                      string   `yaml:"prevTab"`
-	NextScreenMode               string   `yaml:"nextScreenMode"`
-	PrevScreenMode               string   `yaml:"prevScreenMode"`
-	Undo                         string   `yaml:"undo"`
-	Redo                         string   `yaml:"redo"`
-	FilteringMenu                string   `yaml:"filteringMenu"`
-	DiffingMenu                  string   `yaml:"diffingMenu"`
-	DiffingMenuAlt               string   `yaml:"diffingMenu-alt"`
-	CopyToClipboard              string   `yaml:"copyToClipboard"`
-	OpenRecentRepos              string   `yaml:"openRecentRepos"`
-	SubmitEditorText             string   `yaml:"submitEditorText"`
-	AppendNewline                string   `yaml:"appendNewline"`
-	ExtrasMenu                   string   `yaml:"extrasMenu"`
-	ToggleWhitespaceInDiffView   string   `yaml:"toggleWhitespaceInDiffView"`
+	Quit                         string `yaml:"quit"`
+	QuitAlt1                     string `yaml:"quit-alt1"`
+	Return                       string `yaml:"return"`
+	QuitWithoutChangingDirectory string `yaml:"quitWithoutChangingDirectory"`
+	TogglePanel                  string `yaml:"togglePanel"`
+	PrevItem                     string `yaml:"prevItem"`
+	NextItem                     string `yaml:"nextItem"`
+	PrevItemAlt                  string `yaml:"prevItem-alt"`
+	NextItemAlt                  string `yaml:"nextItem-alt"`
+	PrevPage                     string `yaml:"prevPage"`
+	NextPage                     string `yaml:"nextPage"`
+	GotoTop                      string `yaml:"gotoTop"`
+	GotoBottom                   string `yaml:"gotoBottom"`
+	PrevBlock                    string `yaml:"prevBlock"`
+	NextBlock                    string `yaml:"nextBlock"`
+	PrevBlockAlt                 string `yaml:"prevBlock-alt"`
+	NextBlockAlt                 string `yaml:"nextBlock-alt"`
+	NextMatch                    string `yaml:"nextMatch"`
+	PrevMatch                    string `yaml:"prevMatch"`
+	StartSearch                  string `yaml:"startSearch"`
+	OptionMenu                   string `yaml:"optionMenu"`
+	OptionMenuAlt1               string `yaml:"optionMenu-alt1"`
+	Select                       string `yaml:"select"`
+	GoInto                       string `yaml:"goInto"`
+	Confirm                      string `yaml:"confirm"`
+	ConfirmAlt1                  string `yaml:"confirm-alt1"`
+	Remove                       string `yaml:"remove"`
+	New                          string `yaml:"new"`
+	Edit                         string `yaml:"edit"`
+	OpenFile                     string `yaml:"openFile"`
+	ScrollUpMain                 string `yaml:"scrollUpMain"`
+	ScrollDownMain               string `yaml:"scrollDownMain"`
+	ScrollUpMainAlt1             string `yaml:"scrollUpMain-alt1"`
+	ScrollDownMainAlt1           string `yaml:"scrollDownMain-alt1"`
+	ScrollUpMainAlt2             string `yaml:"scrollUpMain-alt2"`
+	ScrollDownMainAlt2           string `yaml:"scrollDownMain-alt2"`
+	ExecuteCustomCommand         string `yaml:"executeCustomCommand"`
+	CreateRebaseOptionsMenu      string `yaml:"createRebaseOptionsMenu"`
+	PushFiles                    string `yaml:"pushFiles"`
+	PullFiles                    string `yaml:"pullFiles"`
+	Refresh                      string `yaml:"refresh"`
+	CreatePatchOptionsMenu       string `yaml:"createPatchOptionsMenu"`
+	NextTab                      string `yaml:"nextTab"`
+	PrevTab                      string `yaml:"prevTab"`
+	NextScreenMode               string `yaml:"nextScreenMode"`
+	PrevScreenMode               string `yaml:"prevScreenMode"`
+	Undo                         string `yaml:"undo"`
+	Redo                         string `yaml:"redo"`
+	FilteringMenu                string `yaml:"filteringMenu"`
+	DiffingMenu                  string `yaml:"diffingMenu"`
+	DiffingMenuAlt               string `yaml:"diffingMenu-alt"`
+	CopyToClipboard              string `yaml:"copyToClipboard"`
+	SubmitEditorText             string `yaml:"submitEditorText"`
+	AppendNewline                string `yaml:"appendNewline"`
 }

 type KeybindingStatusConfig struct {
-	CheckForUpdate      string `yaml:"checkForUpdate"`
-	RecentRepos         string `yaml:"recentRepos"`
-	AllBranchesLogGraph string `yaml:"allBranchesLogGraph"`
+	CheckForUpdate string `yaml:"checkForUpdate"`
+	RecentRepos    string `yaml:"recentRepos"`
 }

 type KeybindingFilesConfig struct {
@@ -196,15 +165,10 @@ type KeybindingFilesConfig struct {
 	ToggleStagedAll          string `yaml:"toggleStagedAll"`
 	ViewResetOptions         string `yaml:"viewResetOptions"`
 	Fetch                    string `yaml:"fetch"`
-	ToggleTreeView           string `yaml:"toggleTreeView"`
-	OpenMergeTool            string `yaml:"openMergeTool"`
-	OpenStatusFilter         string `yaml:"openStatusFilter"`
 }

 type KeybindingBranchesConfig struct {
 	CreatePullRequest      string `yaml:"createPullRequest"`
-	ViewPullRequestOptions string `yaml:"viewPullRequestOptions"`
-	CopyPullRequestURL     string `yaml:"copyPullRequestURL"`
 	CheckoutBranchByName   string `yaml:"checkoutBranchByName"`
 	ForceCheckoutBranch    string `yaml:"forceCheckoutBranch"`
 	RebaseBranch           string `yaml:"rebaseBranch"`
@@ -237,7 +201,6 @@ type KeybindingCommitsConfig struct {
 	CheckoutCommit               string `yaml:"checkoutCommit"`
 	ResetCherryPick              string `yaml:"resetCherryPick"`
 	CopyCommitMessageToClipboard string `yaml:"copyCommitMessageToClipboard"`
-	OpenLogMenu                  string `yaml:"openLogMenu"`
 }

 type KeybindingStashConfig struct {
@@ -263,12 +226,6 @@ type KeybindingSubmodulesConfig struct {

 // OSConfig contains config on the level of the os
 type OSConfig struct {
-	// EditCommand is the command for editing a file
-	EditCommand string `yaml:"editCommand,omitempty"`
-
-	// EditCommandTemplate is the command template for editing a file
-	EditCommandTemplate string `yaml:"editCommandTemplate,omitempty"`
-
 	// OpenCommand is the command for opening a file
 	OpenCommand string `yaml:"openCommand,omitempty"`

@@ -295,12 +252,6 @@ type CustomCommandPrompt struct {

 	// this only applies to menus
 	Options []CustomCommandMenuOption
-
-	// this only applies to menuFromCommand
-	Command     string `yaml:"command"`
-	Filter      string `yaml:"filter"`
-	ValueFormat string `yaml:"valueFormat"`
-	LabelFormat string `yaml:"labelFormat"`
 }

 type CustomCommandMenuOption struct {
@@ -320,24 +271,15 @@ func GetDefaultConfig() *UserConfig {
 			SidePanelWidth:         0.3333,
 			ExpandFocusedSidePanel: false,
 			MainPanelSplitMode:     "flexible",
-			Language:               "auto",
 			Theme: ThemeConfig{
-				LightTheme:                false,
-				ActiveBorderColor:         []string{"green", "bold"},
-				InactiveBorderColor:       []string{"white"},
-				OptionsTextColor:          []string{"blue"},
-				SelectedLineBgColor:       []string{"default"},
-				SelectedRangeBgColor:      []string{"blue"},
-				CherryPickedCommitBgColor: []string{"blue"},
-				CherryPickedCommitFgColor: []string{"cyan"},
+				LightTheme:           false,
+				ActiveBorderColor:    []string{"green", "bold"},
+				InactiveBorderColor:  []string{"white"},
+				OptionsTextColor:     []string{"blue"},
+				SelectedLineBgColor:  []string{"default"},
+				SelectedRangeBgColor: []string{"blue"},
 			},
-			CommitLength:             CommitLengthConfig{Show: true},
-			SkipNoStagedFilesWarning: false,
-			ShowListFooter:           true,
-			ShowCommandLog:           true,
-			ShowFileTree:             true,
-			ShowRandomTip:            true,
-			CommandLogSize:           8,
+			CommitLength: CommitLengthConfig{Show: true},
 		},
 		Git: GitConfig{
 			Paging: PagingConfig{
@@ -348,21 +290,15 @@ func GetDefaultConfig() *UserConfig {
 				ManualCommit: false,
 				Args:         "",
 			},
-			Log: LogConfig{
-				Order:     "topo-order",
-				ShowGraph: "when-maximised",
+			Pull: PullConfig{
+				Mode: "merge",
 			},
 			SkipHookPrefix:      "WIP",
 			AutoFetch:           true,
 			BranchLogCmd:        "git log --graph --color=always --abbrev-commit --decorate --date=relative --pretty=medium {{branchName}} --",
-			AllBranchesLogCmd:   "git log --graph --all --color=always --abbrev-commit --decorate --date=relative  --pretty=medium",
+			OverrideGpg:         false,
 			DisableForcePushing: false,
 			CommitPrefixes:      map[string]CommitPrefixConfig(nil),
-			ParseEmoji:          false,
-		},
-		Refresher: RefresherConfig{
-			RefreshInterval: 10,
-			FetchInterval:   60,
 		},
 		Update: UpdateConfig{
 			Method: "prompt",
@@ -371,7 +307,7 @@ func GetDefaultConfig() *UserConfig {
 		Reporting:            "undetermined",
 		SplashUpdatesIndex:   0,
 		ConfirmOnQuit:        false,
-		QuitOnTopLevelReturn: false,
+		QuitOnTopLevelReturn: true,
 		Keybinding: KeybindingConfig{
 			Universal: KeybindingUniversalConfig{
 				Quit:                         "q",
@@ -385,17 +321,12 @@ func GetDefaultConfig() *UserConfig {
 				NextItemAlt:                  "j",
 				PrevPage:                     ",",
 				NextPage:                     ".",
-				ScrollLeft:                   "H",
-				ScrollRight:                  "L",
 				GotoTop:                      "<",
 				GotoBottom:                   ">",
 				PrevBlock:                    "<left>",
 				NextBlock:                    "<right>",
 				PrevBlockAlt:                 "h",
 				NextBlockAlt:                 "l",
-				PrevBlockAlt2:                "<backtab>",
-				NextBlockAlt2:                "<tab>",
-				JumpToBlock:                  []string{"1", "2", "3", "4", "5"},
 				NextMatch:                    "n",
 				PrevMatch:                    "N",
 				StartSearch:                  "/",
@@ -409,7 +340,6 @@ func GetDefaultConfig() *UserConfig {
 				New:                          "n",
 				Edit:                         "e",
 				OpenFile:                     "o",
-				OpenRecentRepos:              "<c-r>",
 				ScrollUpMain:                 "<pgup>",
 				ScrollDownMain:               "<pgdown>",
 				ScrollUpMainAlt1:             "K",
@@ -433,14 +363,11 @@ func GetDefaultConfig() *UserConfig {
 				DiffingMenuAlt:               "<c-e>",
 				CopyToClipboard:              "<c-o>",
 				SubmitEditorText:             "<enter>",
-				AppendNewline:                "<a-enter>",
-				ExtrasMenu:                   "@",
-				ToggleWhitespaceInDiffView:   "<c-w>",
+				AppendNewline:                "<tab>",
 			},
 			Status: KeybindingStatusConfig{
-				CheckForUpdate:      "u",
-				RecentRepos:         "<enter>",
-				AllBranchesLogGraph: "a",
+				CheckForUpdate: "u",
+				RecentRepos:    "<enter>",
 			},
 			Files: KeybindingFilesConfig{
 				CommitChanges:            "c",
@@ -454,14 +381,9 @@ func GetDefaultConfig() *UserConfig {
 				ToggleStagedAll:          "a",
 				ViewResetOptions:         "D",
 				Fetch:                    "f",
-				ToggleTreeView:           "`",
-				OpenMergeTool:            "M",
-				OpenStatusFilter:         "<c-b>",
 			},
 			Branches: KeybindingBranchesConfig{
-				CopyPullRequestURL:     "<c-y>",
 				CreatePullRequest:      "o",
-				ViewPullRequestOptions: "O",
 				CheckoutBranchByName:   "c",
 				ForceCheckoutBranch:    "F",
 				RebaseBranch:           "r",
@@ -493,7 +415,6 @@ func GetDefaultConfig() *UserConfig {
 				CheckoutCommit:               "<space>",
 				ResetCherryPick:              "<c-R>",
 				CopyCommitMessageToClipboard: "<c-y>",
-				OpenLogMenu:                  "<c-l>",
 			},
 			Stash: KeybindingStashConfig{
 				PopStash: "g",
@@ -517,6 +438,5 @@ func GetDefaultConfig() *UserConfig {
 		DisableStartupPopups: false,
 		CustomCommands:       []CustomCommand(nil),
 		Services:             map[string]string(nil),
-		NotARepository:       "prompt",
 	}
 }
@@ -1,35 +0,0 @@
-package constants
-
-type Docs struct {
-	CustomPagers      string
-	CustomCommands    string
-	CustomKeybindings string
-	Keybindings       string
-	Undoing           string
-	Config            string
-	Tutorial          string
-}
-
-var Links = struct {
-	Docs        Docs
-	Issues      string
-	Donate      string
-	Discussions string
-	RepoUrl     string
-	Releases    string
-}{
-	RepoUrl:     "https://github.com/jesseduffield/lazygit",
-	Issues:      "https://github.com/jesseduffield/lazygit/issues",
-	Donate:      "https://github.com/sponsors/jesseduffield",
-	Discussions: "https://github.com/jesseduffield/lazygit/discussions",
-	Releases:    "https://github.com/jesseduffield/lazygit/releases",
-	Docs: Docs{
-		CustomPagers:      "https://github.com/jesseduffield/lazygit/blob/master/docs/Custom_Pagers.md",
-		CustomKeybindings: "https://github.com/jesseduffield/lazygit/blob/master/docs/keybindings/Custom_Keybindings.md",
-		CustomCommands:    "https://github.com/jesseduffield/lazygit/wiki/Custom-Commands-Compendium",
-		Keybindings:       "https://github.com/jesseduffield/lazygit/blob/master/docs/keybindings",
-		Undoing:           "https://github.com/jesseduffield/lazygit/blob/master/docs/Undoing.md",
-		Config:            "https://github.com/jesseduffield/lazygit/blob/master/docs/Config.md",
-		Tutorial:          "https://youtu.be/VDXvbHZYeKY",
-	},
-}
@@ -1,7 +1,6 @@
 package gui

 import (
-	"sync"
 	"time"

 	"github.com/jesseduffield/gocui"
@@ -9,68 +8,33 @@ import (
 )

 type appStatus struct {
-	message    string
+	name       string
 	statusType string
-	id         int
+	duration   int
 }

 type statusManager struct {
 	statuses []appStatus
-	nextId   int
-	mutex    sync.Mutex
 }

-func (m *statusManager) removeStatus(id int) {
-	m.mutex.Lock()
-	defer m.mutex.Unlock()
-
+func (m *statusManager) removeStatus(name string) {
 	newStatuses := []appStatus{}
 	for _, status := range m.statuses {
-		if status.id != id {
+		if status.name != name {
 			newStatuses = append(newStatuses, status)
 		}
 	}
 	m.statuses = newStatuses
 }

-func (m *statusManager) addWaitingStatus(message string) int {
-	m.mutex.Lock()
-	defer m.mutex.Unlock()
-
-	m.nextId += 1
-	id := m.nextId
-
+func (m *statusManager) addWaitingStatus(name string) {
+	m.removeStatus(name)
 	newStatus := appStatus{
-		message:    message,
+		name:       name,
 		statusType: "waiting",
-		id:         id,
+		duration:   0,
 	}
 	m.statuses = append([]appStatus{newStatus}, m.statuses...)
-
-	return id
-}
-
-func (m *statusManager) addToastStatus(message string) int {
-	m.mutex.Lock()
-	defer m.mutex.Unlock()
-
-	m.nextId++
-	id := m.nextId
-
-	newStatus := appStatus{
-		message:    message,
-		statusType: "toast",
-		id:         id,
-	}
-	m.statuses = append([]appStatus{newStatus}, m.statuses...)
-
-	go func() {
-		time.Sleep(time.Second * 2)
-
-		m.removeStatus(id)
-	}()
-
-	return id
 }

 func (m *statusManager) getStatusString() string {
@@ -79,42 +43,31 @@ func (m *statusManager) getStatusString() string {
 	}
 	topStatus := m.statuses[0]
 	if topStatus.statusType == "waiting" {
-		return topStatus.message + " " + utils.Loader()
+		return topStatus.name + " " + utils.Loader()
 	}
-	return topStatus.message
-}
-
-func (gui *Gui) raiseToast(message string) {
-	gui.statusManager.addToastStatus(message)
-
-	gui.renderAppStatus()
-}
-
-func (gui *Gui) renderAppStatus() {
-	go utils.Safe(func() {
-		ticker := time.NewTicker(time.Millisecond * 50)
-		defer ticker.Stop()
-		for range ticker.C {
-			appStatus := gui.statusManager.getStatusString()
-			if appStatus == "" {
-				gui.renderString(gui.Views.AppStatus, "")
-				return
-			}
-			gui.renderString(gui.Views.AppStatus, appStatus)
-		}
-	})
+	return topStatus.name
 }

 // WithWaitingStatus wraps a function and shows a waiting status while the function is still executing
-func (gui *Gui) WithWaitingStatus(message string, f func() error) error {
+func (gui *Gui) WithWaitingStatus(name string, f func() error) error {
 	go utils.Safe(func() {
-		id := gui.statusManager.addWaitingStatus(message)
+		gui.statusManager.addWaitingStatus(name)

 		defer func() {
-			gui.statusManager.removeStatus(id)
+			gui.statusManager.removeStatus(name)
 		}()

-		gui.renderAppStatus()
+		go utils.Safe(func() {
+			ticker := time.NewTicker(time.Millisecond * 50)
+			defer ticker.Stop()
+			for range ticker.C {
+				appStatus := gui.statusManager.getStatusString()
+				if appStatus == "" {
+					return
+				}
+				gui.renderString("appStatus", appStatus)
+			}
+		})

 		if err := f(); err != nil {
 			gui.g.Update(func(g *gocui.Gui) error {
@@ -5,8 +5,6 @@ import (
 	"github.com/jesseduffield/lazygit/pkg/utils"
 )

-const INFO_SECTION_PADDING = " "
-
 func (gui *Gui) mainSectionChildren() []*boxlayout.Box {
 	currentWindow := gui.currentWindow()

@@ -132,24 +130,6 @@ func (gui *Gui) splitMainPanelSideBySide() bool {
 	}
 }

-func (gui *Gui) getExtrasWindowSize(screenHeight int) int {
-	if !gui.ShowExtrasWindow {
-		return 0
-	}
-
-	var baseSize int
-	if gui.currentStaticContext().GetKey() == COMMAND_LOG_CONTEXT_KEY {
-		baseSize = 1000 // my way of saying 'fill the available space'
-	} else if screenHeight < 40 {
-		baseSize = 1
-	} else {
-		baseSize = gui.Config.GetUserConfig().Gui.CommandLogSize
-	}
-
-	frameSize := 2
-	return baseSize + frameSize
-}
-
 func (gui *Gui) getWindowDimensions(informationStr string, appStatus string) map[string]boxlayout.Dimensions {
 	width, height := gui.g.Size()

@@ -166,8 +146,6 @@ func (gui *Gui) getWindowDimensions(informationStr string, appStatus string) map
 		mainPanelsDirection = boxlayout.COLUMN
 	}

-	extrasWindowSize := gui.getExtrasWindowSize(height)
-
 	root := &boxlayout.Box{
 		Direction: boxlayout.ROW,
 		Children: []*boxlayout.Box{
@@ -181,19 +159,9 @@ func (gui *Gui) getWindowDimensions(informationStr string, appStatus string) map
 						ConditionalChildren: gui.sidePanelChildren,
 					},
 					{
-						Direction: boxlayout.ROW,
+						Direction: mainPanelsDirection,
 						Weight:    mainSectionWeight,
-						Children: []*boxlayout.Box{
-							{
-								Direction: mainPanelsDirection,
-								Children:  gui.mainSectionChildren(),
-								Weight:    1,
-							},
-							{
-								Window: "extras",
-								Size:   extrasWindowSize,
-							},
-						},
+						Children:  gui.mainSectionChildren(),
 					},
 				},
 			},
@@ -210,15 +178,12 @@ func (gui *Gui) getWindowDimensions(informationStr string, appStatus string) map

 // The stash window by default only contains one line so that it's not hogging
 // too much space, but if you access it it should take up some space. This is
-// the default behaviour when accordion mode is NOT in effect. If it is in effect
+// the default behaviour when accordian mode is NOT in effect. If it is in effect
 // then when it's accessed it will have weight 2, not 1.
 func (gui *Gui) getDefaultStashWindowBox() *boxlayout.Box {
-	gui.State.ContextManager.RLock()
-	defer gui.State.ContextManager.RUnlock()
-
 	box := &boxlayout.Box{Window: "stash"}
 	stashWindowAccessed := false
-	for _, context := range gui.State.ContextManager.ContextStack {
+	for _, context := range gui.State.ContextStack {
 		if context.GetWindowName() == "stash" {
 			stashWindowAccessed = true
 		}
@@ -259,9 +224,9 @@ func (gui *Gui) sidePanelChildren(width int, height int) []*boxlayout.Box {
 			fullHeightBox("stash"),
 		}
 	} else if height >= 28 {
-		accordionMode := gui.Config.GetUserConfig().Gui.ExpandFocusedSidePanel
-		accordionBox := func(defaultBox *boxlayout.Box) *boxlayout.Box {
-			if accordionMode && defaultBox.Window == currentWindow {
+		accordianMode := gui.Config.GetUserConfig().Gui.ExpandFocusedSidePanel
+		accordianBox := func(defaultBox *boxlayout.Box) *boxlayout.Box {
+			if accordianMode && defaultBox.Window == currentWindow {
 				return &boxlayout.Box{
 					Window: defaultBox.Window,
 					Weight: 2,
@@ -276,10 +241,10 @@ func (gui *Gui) sidePanelChildren(width int, height int) []*boxlayout.Box {
 				Window: "status",
 				Size:   3,
 			},
-			accordionBox(&boxlayout.Box{Window: "files", Weight: 1}),
-			accordionBox(&boxlayout.Box{Window: "branches", Weight: 1}),
-			accordionBox(&boxlayout.Box{Window: "commits", Weight: 1}),
-			accordionBox(gui.getDefaultStashWindowBox()),
+			accordianBox(&boxlayout.Box{Window: "files", Weight: 1}),
+			accordianBox(&boxlayout.Box{Window: "branches", Weight: 1}),
+			accordianBox(&boxlayout.Box{Window: "commits", Weight: 1}),
+			accordianBox(gui.getDefaultStashWindowBox()),
 		}
 	} else {
 		squashedHeight := 1
@@ -313,12 +278,9 @@ func (gui *Gui) sidePanelChildren(width int, height int) []*boxlayout.Box {

 func (gui *Gui) currentSideWindowName() string {
 	// there is always one and only one cyclable context in the context stack. We'll look from top to bottom
-	gui.State.ContextManager.RLock()
-	defer gui.State.ContextManager.RUnlock()
-
-	for idx := range gui.State.ContextManager.ContextStack {
-		reversedIdx := len(gui.State.ContextManager.ContextStack) - 1 - idx
-		context := gui.State.ContextManager.ContextStack[reversedIdx]
+	for idx := range gui.State.ContextStack {
+		reversedIdx := len(gui.State.ContextStack) - 1 - idx
+		context := gui.State.ContextStack[reversedIdx]

 		if context.GetKind() == SIDE_CONTEXT {
 			return context.GetWindowName()
@@ -1,77 +0,0 @@
-package gui
-
-type BasicContext struct {
-	OnFocus         func() error
-	OnFocusLost     func() error
-	OnRender        func() error
-	Kind            ContextKind
-	Key             ContextKey
-	ViewName        string
-	WindowName      string
-	OnGetOptionsMap func() map[string]string
-
-	ParentContext Context
-	// we can't know on the calling end whether a Context is actually a nil value without reflection, so we're storing this flag here to tell us. There has got to be a better way around this
-	hasParent bool
-}
-
-func (c *BasicContext) GetOptionsMap() map[string]string {
-	if c.OnGetOptionsMap != nil {
-		return c.OnGetOptionsMap()
-	}
-	return nil
-}
-
-func (c *BasicContext) SetParentContext(context Context) {
-	c.ParentContext = context
-	c.hasParent = true
-}
-
-func (c *BasicContext) GetParentContext() (Context, bool) {
-	return c.ParentContext, c.hasParent
-}
-
-func (c *BasicContext) SetWindowName(windowName string) {
-	c.WindowName = windowName
-}
-
-func (c *BasicContext) GetWindowName() string {
-	windowName := c.WindowName
-
-	if windowName != "" {
-		return windowName
-	}
-
-	// TODO: actually set this for everything so we don't default to the view name
-	return c.ViewName
-}
-
-func (c *BasicContext) HandleRender() error {
-	if c.OnRender != nil {
-		return c.OnRender()
-	}
-	return nil
-}
-
-func (c *BasicContext) GetViewName() string {
-	return c.ViewName
-}
-
-func (c *BasicContext) HandleFocus() error {
-	return c.OnFocus()
-}
-
-func (c *BasicContext) HandleFocusLost() error {
-	if c.OnFocusLost != nil {
-		return c.OnFocusLost()
-	}
-	return nil
-}
-
-func (c *BasicContext) GetKind() ContextKind {
-	return c.Kind
-}
-
-func (c *BasicContext) GetKey() ContextKey {
-	return c.Key
-}
@@ -9,10 +9,8 @@ type Dimensions struct {
 	Y1 int
 }

-type Direction int
-
 const (
-	ROW Direction = iota
+	ROW = iota
 	COLUMN
 )

@@ -28,10 +26,10 @@ const (

 type Box struct {
 	// Direction decides how the children boxes are laid out. ROW means the children will each form a row i.e. that they will be stacked on top of eachother.
-	Direction Direction
+	Direction int // ROW or COLUMN

 	// function which takes the width and height assigned to the box and decides which orientation it will have
-	ConditionalDirection func(width int, height int) Direction
+	ConditionalDirection func(width int, height int) int

 	Children []*Box

@@ -96,11 +94,6 @@ func ArrangeWindows(root *Box, x0, y0, width, height int) map[string]Dimensions
 		var boxSize int
 		if child.isStatic() {
 			boxSize = child.Size
-			// assuming that only one static child can have a size greater than the
-			// available space. In that case we just crop the size to what's available
-			if boxSize > availableSize {
-				boxSize = availableSize
-			}
 		} else {
 			// TODO: consider more evenly distributing the remainder
 			boxSize = unitSize * child.Weight
@@ -127,7 +120,7 @@ func (b *Box) isStatic() bool {
 	return b.Size > 0
 }

-func (b *Box) getDirection(width int, height int) Direction {
+func (b *Box) getDirection(width int, height int) int {
 	if b.ConditionalDirection != nil {
 		return b.ConditionalDirection(width, height)
 	}
@@ -87,7 +87,7 @@ func TestArrangeWindows(t *testing.T) {
 		},
 		{
 			"Box with COLUMN direction only on wide boxes with narrow box",
-			&Box{ConditionalDirection: func(width int, height int) Direction {
+			&Box{ConditionalDirection: func(width int, height int) int {
 				if width > 4 {
 					return COLUMN
 				} else {
@@ -111,7 +111,7 @@ func TestArrangeWindows(t *testing.T) {
 		},
 		{
 			"Box with COLUMN direction only on wide boxes with wide box",
-			&Box{ConditionalDirection: func(width int, height int) Direction {
+			&Box{ConditionalDirection: func(width int, height int) int {
 				if width > 4 {
 					return COLUMN
 				} else {
@@ -179,31 +179,9 @@ func TestArrangeWindows(t *testing.T) {
 				)
 			},
 		},
-		{
-			"Box with static child with size too large",
-			&Box{Direction: COLUMN, Children: []*Box{{Size: 11, Window: "static"}, {Weight: 1, Window: "dynamic1"}, {Weight: 2, Window: "dynamic2"}}},
-			0,
-			0,
-			10,
-			10,
-			func(result map[string]Dimensions) {
-				assert.EqualValues(
-					t,
-					result,
-					map[string]Dimensions{
-						"static": {X0: 0, X1: 9, Y0: 0, Y1: 9},
-						// not sure if X0: 10, X1: 9 makes any sense, but testing this in the
-						// actual GUI it seems harmless
-						"dynamic1": {X0: 10, X1: 9, Y0: 0, Y1: 9},
-						"dynamic2": {X0: 10, X1: 9, Y0: 0, Y1: 9},
-					},
-				)
-			},
-		},
 	}

 	for _, s := range scenarios {
-		s := s
 		t.Run(s.testName, func(t *testing.T) {
 			s.test(ArrangeWindows(s.root, s.x0, s.y0, s.width, s.height))
 		})
@@ -4,9 +4,9 @@ import (
 	"fmt"
 	"strings"

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

@@ -29,13 +29,13 @@ func (gui *Gui) handleBranchSelect() error {
 	var task updateTask
 	branch := gui.getSelectedBranch()
 	if branch == nil {
-		task = NewRenderStringTask(gui.Tr.NoBranchesThisRepo)
+		task = gui.createRenderStringTask(gui.Tr.NoBranchesThisRepo)
 	} else {
 		cmd := gui.OSCommand.ExecutableFromString(
 			gui.GitCommand.GetBranchGraphCmdStr(branch.Name),
 		)

-		task = NewRunPtyTask(cmd)
+		task = gui.createRunPtyTask(cmd)
 	}

 	return gui.refreshMainViews(refreshMainOpts{
@@ -68,7 +68,7 @@ func (gui *Gui) refreshBranches() {
 	}
 	gui.State.Branches = builder.Build()

-	if err := gui.postRefreshUpdate(gui.State.Contexts.Branches); err != nil {
+	if err := gui.postRefreshUpdate(gui.Contexts.Branches.Context); err != nil {
 		gui.Log.Error(err)
 	}

@@ -77,7 +77,7 @@ func (gui *Gui) refreshBranches() {

 // specific functions

-func (gui *Gui) handleBranchPress() error {
+func (gui *Gui) handleBranchPress(g *gocui.Gui, v *gocui.View) error {
 	if gui.State.Panels.Branches.SelectedLineIdx == -1 {
 		return nil
 	}
@@ -85,52 +85,33 @@ 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})
+	return gui.handleCheckoutRef(branch.Name, handleCheckoutRefOptions{})
 }

-func (gui *Gui) handleCreatePullRequestPress() error {
-	branch := gui.getSelectedBranch()
-	return gui.createPullRequest(branch.Name, "")
-}
-
-func (gui *Gui) handleCreatePullRequestMenu() error {
-	selectedBranch := gui.getSelectedBranch()
-	if selectedBranch == nil {
-		return nil
-	}
-	checkedOutBranch := gui.getCheckedOutBranch()
-
-	return gui.createPullRequestMenu(selectedBranch, checkedOutBranch)
-}
-
-func (gui *Gui) handleCopyPullRequestURLPress() error {
+func (gui *Gui) handleCreatePullRequestPress(g *gocui.Gui, v *gocui.View) error {
 	pullRequest := commands.NewPullRequest(gui.GitCommand)

 	branch := gui.getSelectedBranch()
-	url, err := pullRequest.CopyURL(branch.Name, "")
-	if err != nil {
+	if err := pullRequest.Create(branch); 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
 }

-func (gui *Gui) handleGitFetch() error {
-	if err := gui.createLoaderPanel(gui.Tr.FetchWait); err != nil {
+func (gui *Gui) handleGitFetch(g *gocui.Gui, v *gocui.View) error {
+	if err := gui.createLoaderPanel(v, gui.Tr.FetchWait); err != nil {
 		return err
 	}
 	go utils.Safe(func() {
-		err := gui.fetch(true, "Fetch")
+		err := gui.fetch(true)
 		gui.handleCredentialsPopup(err)
 		_ = gui.refreshSidePanels(refreshOptions{mode: ASYNC})
 	})
 	return nil
 }

-func (gui *Gui) handleForceCheckout() error {
+func (gui *Gui) handleForceCheckout(g *gocui.Gui, v *gocui.View) error {
 	branch := gui.getSelectedBranch()
 	message := gui.Tr.SureForceCheckout
 	title := gui.Tr.ForceCheckoutBranch
@@ -139,7 +120,7 @@ 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 {
+			if err := gui.GitCommand.Checkout(branch.Name, commands.CheckoutOptions{Force: true}); err != nil {
 				_ = gui.surfaceError(err)
 			}
 			return gui.refreshSidePanels(refreshOptions{mode: ASYNC})
@@ -151,7 +132,6 @@ type handleCheckoutRefOptions struct {
 	WaitingStatus string
 	EnvVars       []string
 	onRefNotFound func(ref string) error
-	span          string
 }

 func (gui *Gui) handleCheckoutRef(ref string, options handleCheckoutRefOptions) error {
@@ -169,10 +149,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.GitCommand.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") {
@@ -186,15 +164,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.GitCommand.StashSave(gui.Tr.StashPrefix + ref); err != nil {
 							return gui.surfaceError(err)
 						}
-						if err := gitCommand.Checkout(ref, cmdOptions); err != nil {
+						if err := gui.GitCommand.Checkout(ref, cmdOptions); err != nil {
 							return gui.surfaceError(err)
 						}

 						onSuccess()
-						if err := gitCommand.StashDo(0, "pop"); err != nil {
+						if err := gui.GitCommand.StashDo(0, "pop"); err != nil {
 							if err := gui.refreshSidePanels(refreshOptions{mode: BLOCK_UI}); err != nil {
 								return err
 							}
@@ -215,26 +193,22 @@ func (gui *Gui) handleCheckoutRef(ref string, options handleCheckoutRefOptions)
 	})
 }

-func (gui *Gui) handleCheckoutByName() error {
-	return gui.prompt(promptOpts{
-		title:               gui.Tr.BranchName + ":",
-		findSuggestionsFunc: gui.getRefsSuggestionsFunc(),
-		handleConfirm: func(response string) error {
-			return gui.handleCheckoutRef(response, handleCheckoutRefOptions{
-				span: "Checkout branch",
-				onRefNotFound: func(ref string) error {
+func (gui *Gui) handleCheckoutByName(g *gocui.Gui, v *gocui.View) error {
+	return gui.prompt(gui.Tr.BranchName+":", "", func(response string) error {
+		return gui.handleCheckoutRef(response, handleCheckoutRefOptions{
+			onRefNotFound: func(ref string) error {

-					return gui.ask(askOpts{
-						title:  gui.Tr.BranchNotFoundTitle,
-						prompt: fmt.Sprintf("%s %s%s", gui.Tr.BranchNotFoundPrompt, ref, "?"),
-						handleConfirm: func() error {
-							return gui.createNewBranchWithName(ref)
-						},
-					})
-				},
-			})
-		}},
-	)
+				return gui.ask(askOpts{
+
+					title:  gui.Tr.BranchNotFoundTitle,
+					prompt: fmt.Sprintf("%s %s%s", gui.Tr.BranchNotFoundPrompt, ref, "?"),
+					handleConfirm: func() error {
+						return gui.createNewBranchWithName(ref)
+					},
+				})
+			},
+		})
+	})
 }

 func (gui *Gui) getCheckedOutBranch() *models.Branch {
@@ -259,7 +233,7 @@ func (gui *Gui) createNewBranchWithName(newBranchName string) error {
 	return gui.refreshSidePanels(refreshOptions{mode: ASYNC})
 }

-func (gui *Gui) handleDeleteBranch() error {
+func (gui *Gui) handleDeleteBranch(g *gocui.Gui, v *gocui.View) error {
 	return gui.deleteBranch(false)
 }

@@ -291,17 +265,18 @@ func (gui *Gui) deleteNamedBranch(selectedBranch *models.Branch, force bool) err
 	)

 	return gui.ask(askOpts{
+
 		title:  title,
 		prompt: message,
 		handleConfirm: func() error {
-			if err := gui.GitCommand.WithSpan(gui.Tr.Spans.DeleteBranch).DeleteBranch(selectedBranch.Name, force); err != nil {
+			if err := gui.GitCommand.DeleteBranch(selectedBranch.Name, force); err != nil {
 				errMessage := err.Error()
-				if !force && strings.Contains(errMessage, "git branch -D ") {
+				if !force && strings.Contains(errMessage, "is not fully merged") {
 					return gui.deleteNamedBranch(selectedBranch, true)
 				}
 				return gui.createErrorPanel(errMessage)
 			}
-			return gui.refreshSidePanels(refreshOptions{mode: ASYNC, scope: []RefreshableView{BRANCHES}})
+			return gui.refreshSidePanels(refreshOptions{mode: ASYNC, scope: []int{BRANCHES}})
 		},
 	})
 }
@@ -327,16 +302,17 @@ func (gui *Gui) mergeBranchIntoCheckedOutBranch(branchName string) error {
 	)

 	return gui.ask(askOpts{
+
 		title:  gui.Tr.MergingTitle,
 		prompt: prompt,
 		handleConfirm: func() error {
-			err := gui.GitCommand.WithSpan(gui.Tr.Spans.Merge).Merge(branchName, commands.MergeOpts{})
+			err := gui.GitCommand.Merge(branchName, commands.MergeOpts{})
 			return gui.handleGenericMergeCommandResult(err)
 		},
 	})
 }

-func (gui *Gui) handleMerge() error {
+func (gui *Gui) handleMerge(g *gocui.Gui, v *gocui.View) error {
 	if ok, err := gui.validateNotInFilterMode(); err != nil || !ok {
 		return err
 	}
@@ -345,7 +321,7 @@ func (gui *Gui) handleMerge() error {
 	return gui.mergeBranchIntoCheckedOutBranch(selectedBranchName)
 }

-func (gui *Gui) handleRebaseOntoLocalBranch() error {
+func (gui *Gui) handleRebaseOntoLocalBranch(g *gocui.Gui, v *gocui.View) error {
 	selectedBranchName := gui.getSelectedBranch().Name
 	return gui.handleRebaseOntoBranch(selectedBranchName)
 }
@@ -368,25 +344,28 @@ func (gui *Gui) handleRebaseOntoBranch(selectedBranchName string) error {
 	)

 	return gui.ask(askOpts{
+
 		title:  gui.Tr.RebasingTitle,
 		prompt: prompt,
 		handleConfirm: func() error {
-			err := gui.GitCommand.WithSpan(gui.Tr.Spans.RebaseBranch).RebaseBranch(selectedBranchName)
+			err := gui.GitCommand.RebaseBranch(selectedBranchName)
 			return gui.handleGenericMergeCommandResult(err)
 		},
 	})
 }

-func (gui *Gui) handleFastForward() error {
+func (gui *Gui) handleFastForward(g *gocui.Gui, v *gocui.View) error {
 	branch := gui.getSelectedBranch()
-	if branch == nil || !branch.IsRealBranch() {
+	if branch == nil {
 		return nil
 	}
-
-	if !branch.IsTrackingRemote() {
+	if branch.Pushables == "" {
+		return nil
+	}
+	if branch.Pushables == "?" {
 		return gui.createErrorPanel(gui.Tr.FwdNoUpstream)
 	}
-	if branch.HasCommitsToPush() {
+	if branch.Pushables != "0" {
 		return gui.createErrorPanel(gui.Tr.FwdCommitsToPush)
 	}

@@ -395,8 +374,6 @@ func (gui *Gui) handleFastForward() error {
 		return gui.surfaceError(err)
 	}

-	span := gui.Tr.Spans.FastForwardBranch
-
 	split := strings.Split(upstream, "/")
 	remoteName := split[0]
 	remoteBranchName := strings.Join(split[1:], "/")
@@ -409,20 +386,20 @@ func (gui *Gui) handleFastForward() error {
 		},
 	)
 	go utils.Safe(func() {
-		_ = gui.createLoaderPanel(message)
+		_ = gui.createLoaderPanel(v, message)

 		if gui.State.Panels.Branches.SelectedLineIdx == 0 {
-			_ = gui.pullWithLock(PullFilesOptions{span: span, FastForwardOnly: true})
+			_ = gui.pullWithMode("ff-only", PullFilesOptions{})
 		} else {
-			err := gui.GitCommand.WithSpan(span).FastForward(branch.Name, remoteName, remoteBranchName, gui.promptUserForCredential)
+			err := gui.GitCommand.FastForward(branch.Name, remoteName, remoteBranchName, gui.promptUserForCredential)
 			gui.handleCredentialsPopup(err)
-			_ = gui.refreshSidePanels(refreshOptions{mode: ASYNC, scope: []RefreshableView{BRANCHES}})
+			_ = gui.refreshSidePanels(refreshOptions{mode: ASYNC, scope: []int{BRANCHES}})
 		}
 	})
 	return nil
 }

-func (gui *Gui) handleCreateResetToBranchMenu() error {
+func (gui *Gui) handleCreateResetToBranchMenu(g *gocui.Gui, v *gocui.View) error {
 	branch := gui.getSelectedBranch()
 	if branch == nil {
 		return nil
@@ -431,47 +408,40 @@ func (gui *Gui) handleCreateResetToBranchMenu() error {
 	return gui.createResetMenu(branch.Name)
 }

-func (gui *Gui) handleRenameBranch() error {
+func (gui *Gui) handleRenameBranch(g *gocui.Gui, v *gocui.View) error {
 	branch := gui.getSelectedBranch()
-	if branch == nil || !branch.IsRealBranch() {
+	if branch == nil {
 		return nil
 	}

+	// TODO: find a way to not checkout the branch here if it's not the current branch (i.e. find some
+	// way to get it to show up in the reflog)
+
 	promptForNewName := func() error {
-		return gui.prompt(promptOpts{
-			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 {
-					return gui.surfaceError(err)
-				}
+		return gui.prompt(gui.Tr.NewBranchNamePrompt+" "+branch.Name+":", "", func(newBranchName string) error {
+			if err := gui.GitCommand.RenameBranch(branch.Name, newBranchName); err != nil {
+				return gui.surfaceError(err)
+			}
+			// need to checkout so that the branch shows up in our reflog and therefore
+			// doesn't get lost among all the other branches when we switch to something else
+			if err := gui.GitCommand.Checkout(newBranchName, commands.CheckoutOptions{Force: false}); err != nil {
+				return gui.surfaceError(err)
+			}

-				// need to find where the branch is now so that we can re-select it. That means we need to refetch the branches synchronously and then find our branch
-				gui.refreshBranches()
-
-				// now that we've got our stuff again we need to find that branch and reselect it.
-				for i, newBranch := range gui.State.Branches {
-					if newBranch.Name == newBranchName {
-						gui.State.Panels.Branches.SetSelectedLineIdx(i)
-						if err := gui.State.Contexts.Branches.HandleRender(); err != nil {
-							return err
-						}
-					}
-				}
-
-				return nil
-			},
+			return gui.refreshSidePanels(refreshOptions{mode: ASYNC})
 		})
 	}

 	// I could do an explicit check here for whether the branch is tracking a remote branch
 	// but if we've selected it we'll already know that via Pullables and Pullables.
 	// Bit of a hack but I'm lazy.
-	if !branch.IsTrackingRemote() {
+	notTrackingRemote := branch.Pullables == "?"
+	if notTrackingRemote {
 		return promptForNewName()
 	}

 	return gui.ask(askOpts{
+
 		title:         gui.Tr.LcRenameBranch,
 		prompt:        gui.Tr.RenameBranchWarning,
 		handleConfirm: promptForNewName,
@@ -486,7 +456,7 @@ func (gui *Gui) currentBranch() *models.Branch {
 }

 func (gui *Gui) handleNewBranchOffCurrentItem() error {
-	context := gui.currentSideListContext()
+	context := gui.currentSideContext()

 	item, ok := context.GetSelectedItem()
 	if !ok {
@@ -502,39 +472,28 @@ func (gui *Gui) handleNewBranchOffCurrentItem() error {

 	prefilledName := ""
 	if context.GetKey() == REMOTE_BRANCHES_CONTEXT_KEY {
-		// will set to the remote's branch name without the remote name
-		prefilledName = strings.SplitAfterN(item.ID(), "/", 2)[1]
+		// will set to the remote's existing name
+		prefilledName = item.ID()
 	}
+	return gui.prompt(message, prefilledName, func(response string) error {
+		if err := gui.GitCommand.NewBranch(response, item.ID()); err != nil {
+			return err
+		}

-	return gui.prompt(promptOpts{
-		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 {
+		// if we're currently in the branch commits context then the selected commit
+		// is about to go to the top of the list
+		if context.GetKey() == BRANCH_COMMITS_CONTEXT_KEY {
+			context.GetPanelState().SetSelectedLineIdx(0)
+		}
+
+		if context.GetKey() != gui.Contexts.Branches.Context.GetKey() {
+			if err := gui.switchContext(gui.Contexts.Branches.Context); err != nil {
 				return err
 			}
+		}

-			// if we're currently in the branch commits context then the selected commit
-			// is about to go to the top of the list
-			if context.GetKey() == BRANCH_COMMITS_CONTEXT_KEY {
-				context.GetPanelState().SetSelectedLineIdx(0)
-			}
+		gui.State.Panels.Branches.SelectedLineIdx = 0

-			if context.GetKey() != gui.State.Contexts.Branches.GetKey() {
-				if err := gui.pushContext(gui.State.Contexts.Branches); err != nil {
-					return err
-				}
-			}
-
-			gui.State.Panels.Branches.SelectedLineIdx = 0
-
-			return gui.refreshSidePanels(refreshOptions{mode: ASYNC})
-		},
+		return gui.refreshSidePanels(refreshOptions{mode: ASYNC})
 	})
 }
-
-// sanitizedBranchName will remove all spaces in favor of a dash "-" to meet
-// git's branch naming requirement.
-func sanitizedBranchName(input string) string {
-	return strings.Replace(input, " ", "-", -1)
-}
@@ -5,11 +5,11 @@ import "github.com/jesseduffield/lazygit/pkg/commands/models"
 // you can only copy from one context at a time, because the order and position of commits matter

 func (gui *Gui) resetCherryPickingIfNecessary(context Context) error {
-	oldContextKey := ContextKey(gui.State.Modes.CherryPicking.ContextKey)
+	oldContextKey := gui.State.Modes.CherryPicking.ContextKey

 	if oldContextKey != context.GetKey() {
 		// need to reset the cherry picking mode
-		gui.State.Modes.CherryPicking.ContextKey = string(context.GetKey())
+		gui.State.Modes.CherryPicking.ContextKey = context.GetKey()
 		gui.State.Modes.CherryPicking.CherryPickedCommits = make([]*models.Commit, 0)

 		return gui.rerenderContextViewIfPresent(oldContextKey)
@@ -24,7 +24,7 @@ func (gui *Gui) handleCopyCommit() error {
 	}

 	// get currently selected commit, add the sha to state.
-	context := gui.currentSideListContext()
+	context := gui.currentSideContext()
 	if context == nil {
 		return nil
 	}
@@ -33,7 +33,7 @@ func (gui *Gui) handleCopyCommit() error {
 		return err
 	}

-	item, ok := context.GetSelectedItem()
+	item, ok := context.SelectedItem()
 	if !ok {
 		return nil
 	}
@@ -63,7 +63,7 @@ func (gui *Gui) cherryPickedCommitShaMap() map[string]bool {
 }

 func (gui *Gui) commitsListForContext() []*models.Commit {
-	context := gui.currentSideListContext()
+	context := gui.currentSideContext()
 	if context == nil {
 		return nil
 	}
@@ -104,7 +104,7 @@ func (gui *Gui) handleCopyCommitRange() error {
 	}

 	// get currently selected commit, add the sha to state.
-	context := gui.currentSideListContext()
+	context := gui.currentSideContext()
 	if context == nil {
 		return nil
 	}
@@ -148,7 +148,7 @@ 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)
+				err := gui.GitCommand.CherryPickCommits(gui.State.Modes.CherryPicking.CherryPickedCommits)
 				return gui.handleGenericMergeCommandResult(err)
 			})
 		},
@@ -156,7 +156,7 @@ func (gui *Gui) HandlePasteCommits() error {
 }

 func (gui *Gui) exitCherryPickingMode() error {
-	contextKey := ContextKey(gui.State.Modes.CherryPicking.ContextKey)
+	contextKey := gui.State.Modes.CherryPicking.ContextKey

 	gui.State.Modes.CherryPicking.ContextKey = ""
 	gui.State.Modes.CherryPicking.CherryPickedCommits = nil
@@ -169,7 +169,7 @@ func (gui *Gui) exitCherryPickingMode() error {
 	return gui.rerenderContextViewIfPresent(contextKey)
 }

-func (gui *Gui) rerenderContextViewIfPresent(contextKey ContextKey) error {
+func (gui *Gui) rerenderContextViewIfPresent(contextKey string) error {
 	if contextKey == "" {
 		return nil
 	}
@@ -184,7 +184,7 @@ func (gui *Gui) rerenderContextViewIfPresent(contextKey ContextKey) error {
 		return nil
 	}

-	if ContextKey(view.Context) == contextKey {
+	if view.Context == contextKey {
 		if err := context.HandleRender(); err != nil {
 			return err
 		}
@@ -1,184 +0,0 @@
-package gui
-
-import (
-	"fmt"
-	"math/rand"
-	"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))
-	}
-}
-
-func (gui *Gui) printCommandLogHeader() {
-	introStr := fmt.Sprintf(
-		gui.Tr.CommandLogHeader,
-		gui.getKeyDisplay(gui.Config.GetUserConfig().Keybinding.Universal.ExtrasMenu),
-	)
-	fmt.Fprintln(gui.Views.Extras, style.FgCyan.Sprint(introStr))
-
-	if gui.Config.GetUserConfig().Gui.ShowRandomTip {
-		fmt.Fprintf(
-			gui.Views.Extras,
-			"%s: %s",
-			style.FgYellow.Sprint(gui.Tr.RandomTip),
-			style.FgGreen.Sprint(gui.getRandomTip()),
-		)
-	}
-}
-
-func (gui *Gui) getRandomTip() string {
-	config := gui.Config.GetUserConfig().Keybinding
-
-	formattedKey := func(key string) string {
-		return gui.getKeyDisplay(key)
-	}
-
-	tips := []string{
-		// keybindings and lazygit-specific advice
-		fmt.Sprintf(
-			"To force push, press '%s' and then if the push is rejected you will be asked if you want to force push",
-			formattedKey(config.Universal.PushFiles),
-		),
-		fmt.Sprintf(
-			"To filter commits by path, press '%s'",
-			formattedKey(config.Universal.FilteringMenu),
-		),
-		fmt.Sprintf(
-			"To start an interactive rebase, press '%s' on a commit. You can always abort the rebase by pressing '%s' and selecting 'abort'",
-			formattedKey(config.Universal.Edit),
-			formattedKey(config.Universal.CreateRebaseOptionsMenu),
-		),
-		fmt.Sprintf(
-			"In flat file view, merge conflicts are sorted to the top. To switch to flat file view press '%s'",
-			formattedKey(config.Files.ToggleTreeView),
-		),
-		"If you want to learn Go and can think of ways to improve lazygit, join the team! Click 'Ask Question' and express your interest",
-		fmt.Sprintf(
-			"If you press '%s'/'%s' you can undo/redo your changes. Be wary though, this only applies to branches/commits, so only do this if your worktree is clear.\nDocs: %s",
-			formattedKey(config.Universal.Undo),
-			formattedKey(config.Universal.Redo),
-			constants.Links.Docs.Undoing,
-		),
-		fmt.Sprintf(
-			"to hard reset onto your current upstream branch, press '%s' in the files panel",
-			formattedKey(config.Files.ViewResetOptions),
-		),
-		fmt.Sprintf(
-			"To push a tag, navigate to the tag in the tags tab and press '%s'",
-			formattedKey(config.Branches.PushTag),
-		),
-		fmt.Sprintf(
-			"You can view the individual files of a stash entry by pressing '%s'",
-			formattedKey(config.Universal.GoInto),
-		),
-		fmt.Sprintf(
-			"You can diff two commits by pressing '%s' on one commit and then navigating to the other. You can then press '%s' to view the files of the diff",
-			formattedKey(config.Universal.DiffingMenu),
-			formattedKey(config.Universal.GoInto),
-		),
-		fmt.Sprintf(
-			"press '%s' on a commit to drop it (delete it)",
-			formattedKey(config.Universal.Remove),
-		),
-		fmt.Sprintf(
-			"If you need to pull out the big guns to resolve merge conflicts, you can press '%s' in the files panel to open 'git mergetool'",
-			formattedKey(config.Files.OpenMergeTool),
-		),
-		fmt.Sprintf(
-			"To revert a commit, press '%s' on that commit",
-			formattedKey(config.Commits.RevertCommit),
-		),
-		fmt.Sprintf(
-			"To escape a mode, for example cherry-picking, patch-building, diffing, or filtering mode, you can just spam the '%s' button. Unless of course you have `quitOnTopLevelReturn` enabled in your config",
-			formattedKey(config.Universal.Return),
-		),
-		fmt.Sprintf(
-			"To search for a string in your panel, press '%s'",
-			formattedKey(config.Universal.StartSearch),
-		),
-		fmt.Sprintf(
-			"You can page through the items of a panel using '%s' and '%s'",
-			formattedKey(config.Universal.PrevPage),
-			formattedKey(config.Universal.NextPage),
-		),
-		fmt.Sprintf(
-			"You can jump to the top/bottom of a panel using '%s' and '%s'",
-			formattedKey(config.Universal.GotoTop),
-			formattedKey(config.Universal.GotoBottom),
-		),
-		fmt.Sprintf(
-			"To collapse/expand a directory, press '%s'",
-			formattedKey(config.Universal.GoInto),
-		),
-		fmt.Sprintf(
-			"You can append your staged changes to an older commit by pressing '%s' on that commit",
-			formattedKey(config.Commits.AmendToCommit),
-		),
-		fmt.Sprintf(
-			"You can amend the last commit with your new file changes by pressing '%s' in the files panel",
-			formattedKey(config.Files.AmendLastCommit),
-		),
-		fmt.Sprintf(
-			"You can now navigate the side panels with '%s' and '%s'",
-			formattedKey(config.Universal.NextBlockAlt2),
-			formattedKey(config.Universal.PrevBlockAlt2),
-		),
-
-		"You can use lazygit with a bare repo by passing the --git-dir and --work-tree arguments as you would for the git CLI",
-
-		// general advice
-		"`git commit` is really just the programmer equivalent of saving your game. Always do it before embarking on an ambitious change!",
-		"Try to separate commits that refactor code from commits that add new functionality: if they're squashed into the one commit, it can be hard to spot what's new.",
-		"If you ever want to experiment, it's easy to create a new branch off your current one and go nuts, then delete it afterwards",
-		"Always read through the diff of your changes before assigning somebody to review your code. Better for you to catch any silly mistakes than your colleagues!",
-		"If something goes wrong, you can always checkout a commit from your reflog to return to an earlier state",
-		"The stash is a good place to save snippets of code that you always find yourself adding when debugging.",
-
-		// links
-		fmt.Sprintf(
-			"If you want a git diff with syntax colouring, check out lazygit's integration with delta:\n%s",
-			constants.Links.Docs.CustomPagers,
-		),
-		fmt.Sprintf(
-			"You can build your own custom menus and commands to run from within lazygit. For examples see:\n%s",
-			constants.Links.Docs.CustomCommands,
-		),
-		fmt.Sprintf(
-			"If you ever find a bug, do not hesitate to raise an issue on the repo:\n%s",
-			constants.Links.Issues,
-		),
-	}
-
-	rand.Seed(time.Now().UnixNano())
-	randomIndex := rand.Intn(len(tips))
-	return tips[randomIndex]
-}
@@ -1,51 +1,34 @@
 package gui

 import (
+	"github.com/jesseduffield/gocui"
 	"github.com/jesseduffield/lazygit/pkg/commands/models"
-	"github.com/jesseduffield/lazygit/pkg/commands/patch"
-	"github.com/jesseduffield/lazygit/pkg/gui/filetree"
 )

-func (gui *Gui) getSelectedCommitFileNode() *filetree.CommitFileNode {
-	selectedLine := gui.State.Panels.CommitFiles.SelectedLineIdx
-	if selectedLine == -1 || selectedLine > gui.State.CommitFileManager.GetItemsLength()-1 {
-		return nil
-	}
-
-	return gui.State.CommitFileManager.GetItemAtIndex(selectedLine)
-}
-
 func (gui *Gui) getSelectedCommitFile() *models.CommitFile {
-	node := gui.getSelectedCommitFileNode()
-	if node == nil {
+	selectedLine := gui.State.Panels.CommitFiles.SelectedLineIdx
+	if selectedLine == -1 || selectedLine > len(gui.State.CommitFiles)-1 {
 		return nil
 	}
-	return node.File
-}

-func (gui *Gui) getSelectedCommitFilePath() string {
-	node := gui.getSelectedCommitFileNode()
-	if node == nil {
-		return ""
-	}
-	return node.GetPath()
+	return gui.State.CommitFiles[selectedLine]
 }

 func (gui *Gui) handleCommitFileSelect() error {
 	gui.escapeLineByLinePanel()

-	node := gui.getSelectedCommitFileNode()
-	if node == nil {
+	commitFile := gui.getSelectedCommitFile()
+	if commitFile == nil {
 		return nil
 	}

-	to := gui.State.CommitFileManager.GetParent()
+	to := commitFile.Parent
 	from, reverse := gui.getFromAndReverseArgsForDiff(to)

 	cmd := gui.OSCommand.ExecutableFromString(
-		gui.GitCommand.ShowFileDiffCmdStr(from, to, reverse, node.GetPath(), false),
+		gui.GitCommand.ShowFileDiffCmdStr(from, to, reverse, commitFile.Name, false),
 	)
-	task := NewRunPtyTask(cmd)
+	task := gui.createRunPtyTask(cmd)

 	return gui.refreshMainViews(refreshMainOpts{
 		main: &viewUpdateOpts{
@@ -56,32 +39,32 @@ func (gui *Gui) handleCommitFileSelect() error {
 	})
 }

-func (gui *Gui) handleCheckoutCommitFile() error {
-	node := gui.getSelectedCommitFileNode()
-	if node == nil {
+func (gui *Gui) handleCheckoutCommitFile(g *gocui.Gui, v *gocui.View) error {
+	file := gui.getSelectedCommitFile()
+	if file == nil {
 		return nil
 	}

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

 	return gui.refreshSidePanels(refreshOptions{mode: ASYNC})
 }

-func (gui *Gui) handleDiscardOldFileChange() error {
+func (gui *Gui) handleDiscardOldFileChange(g *gocui.Gui, v *gocui.View) error {
 	if ok, err := gui.validateNormalWorkingTreeState(); !ok {
 		return err
 	}

-	fileName := gui.getSelectedCommitFileName()
+	fileName := gui.State.CommitFiles[gui.State.Panels.CommitFiles.SelectedLineIdx].Name

 	return gui.ask(askOpts{
 		title:  gui.Tr.DiscardFileChangesTitle,
 		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 {
+				if err := gui.GitCommand.DiscardOldFileChanges(gui.State.Commits, gui.State.Panels.Commits.SelectedLineIdx, fileName); err != nil {
 					if err := gui.handleGenericMergeCommandResult(err); err != nil {
 						return err
 					}
@@ -94,50 +77,43 @@ func (gui *Gui) handleDiscardOldFileChange() error {
 }

 func (gui *Gui) refreshCommitFilesView() error {
-	currentSideContext := gui.currentSideContext()
-	if currentSideContext.GetKey() == COMMIT_FILES_CONTEXT_KEY || currentSideContext.GetKey() == BRANCH_COMMITS_CONTEXT_KEY {
-		if err := gui.handleRefreshPatchBuildingPanel(-1); err != nil {
-			return err
-		}
+	if err := gui.handleRefreshPatchBuildingPanel(-1); err != nil {
+		return err
 	}

 	to := gui.State.Panels.CommitFiles.refName
 	from, reverse := gui.getFromAndReverseArgsForDiff(to)

-	files, err := gui.GitCommand.GetFilesInDiff(from, to, reverse)
+	files, err := gui.GitCommand.GetFilesInDiff(from, to, reverse, gui.GitCommand.PatchManager)
 	if err != nil {
 		return gui.surfaceError(err)
 	}
-	gui.State.CommitFileManager.SetFiles(files, to)
+	gui.State.CommitFiles = files

-	return gui.postRefreshUpdate(gui.State.Contexts.CommitFiles)
+	return gui.postRefreshUpdate(gui.Contexts.CommitFiles.Context)
 }

-func (gui *Gui) handleOpenOldCommitFile() error {
-	node := gui.getSelectedCommitFileNode()
-	if node == nil {
+func (gui *Gui) handleOpenOldCommitFile(g *gocui.Gui, v *gocui.View) error {
+	file := gui.getSelectedCommitFile()
+	if file == nil {
 		return nil
 	}

-	return gui.openFile(node.GetPath())
+	return gui.openFile(file.Name)
 }

-func (gui *Gui) handleEditCommitFile() error {
-	node := gui.getSelectedCommitFileNode()
-	if node == nil {
+func (gui *Gui) handleEditCommitFile(g *gocui.Gui, v *gocui.View) error {
+	file := gui.getSelectedCommitFile()
+	if file == nil {
 		return nil
 	}

-	if node.File == nil {
-		return gui.createErrorPanel(gui.Tr.ErrCannotEditDirectory)
-	}
-
-	return gui.editFile(node.GetPath())
+	return gui.editFile(file.Name)
 }

-func (gui *Gui) handleToggleFileForPatch() error {
-	node := gui.getSelectedCommitFileNode()
-	if node == nil {
+func (gui *Gui) handleToggleFileForPatch(g *gocui.Gui, v *gocui.View) error {
+	commitFile := gui.getSelectedCommitFile()
+	if commitFile == nil {
 		return nil
 	}

@@ -148,32 +124,18 @@ 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
-		})
-
-		err := node.ForEachFile(func(file *models.CommitFile) error {
-			if adding {
-				return gui.GitCommand.PatchManager.AddFileWhole(file.Name)
-			} else {
-				return gui.GitCommand.PatchManager.RemoveFile(file.Name)
-			}
-		})
-
-		if err != nil {
-			return gui.surfaceError(err)
+		if err := gui.GitCommand.PatchManager.ToggleFileWhole(commitFile.Name); err != nil {
+			return err
 		}

 		if gui.GitCommand.PatchManager.IsEmpty() {
 			gui.GitCommand.PatchManager.Reset()
 		}

-		return gui.postRefreshUpdate(gui.State.Contexts.CommitFiles)
+		return gui.refreshCommitFilesView()
 	}

-	if gui.GitCommand.PatchManager.Active() && gui.GitCommand.PatchManager.To != gui.State.CommitFileManager.GetParent() {
+	if gui.GitCommand.PatchManager.Active() && gui.GitCommand.PatchManager.To != commitFile.Parent {
 		return gui.ask(askOpts{
 			title:  gui.Tr.DiscardPatch,
 			prompt: gui.Tr.DiscardPatchConfirm,
@@ -197,20 +159,16 @@ func (gui *Gui) startPatchManager() error {
 	return nil
 }

-func (gui *Gui) handleEnterCommitFile() error {
+func (gui *Gui) handleEnterCommitFile(g *gocui.Gui, v *gocui.View) error {
 	return gui.enterCommitFile(-1)
 }

 func (gui *Gui) enterCommitFile(selectedLineIdx int) error {
-	node := gui.getSelectedCommitFileNode()
-	if node == nil {
+	commitFile := gui.getSelectedCommitFile()
+	if commitFile == nil {
 		return nil
 	}

-	if node.File == nil {
-		return gui.handleToggleCommitFileDirCollapsed()
-	}
-
 	enterTheFile := func(selectedLineIdx int) error {
 		if !gui.GitCommand.PatchManager.Active() {
 			if err := gui.startPatchManager(); err != nil {
@@ -218,13 +176,13 @@ func (gui *Gui) enterCommitFile(selectedLineIdx int) error {
 			}
 		}

-		if err := gui.pushContext(gui.State.Contexts.PatchBuilding); err != nil {
+		if err := gui.switchContext(gui.Contexts.PatchBuilding.Context); err != nil {
 			return err
 		}
 		return gui.handleRefreshPatchBuildingPanel(selectedLineIdx)
 	}

-	if gui.GitCommand.PatchManager.Active() && gui.GitCommand.PatchManager.To != gui.State.CommitFileManager.GetParent() {
+	if gui.GitCommand.PatchManager.Active() && gui.GitCommand.PatchManager.To != commitFile.Parent {
 		return gui.ask(askOpts{
 			title:               gui.Tr.DiscardPatch,
 			prompt:              gui.Tr.DiscardPatchConfirm,
@@ -234,7 +192,7 @@ func (gui *Gui) enterCommitFile(selectedLineIdx int) error {
 				return enterTheFile(selectedLineIdx)
 			},
 			handleClose: func() error {
-				return gui.pushContext(gui.State.Contexts.CommitFiles)
+				return gui.switchContext(gui.Contexts.CommitFiles.Context)
 			},
 		})
 	}
@@ -242,60 +200,20 @@ func (gui *Gui) enterCommitFile(selectedLineIdx int) error {
 	return enterTheFile(selectedLineIdx)
 }

-func (gui *Gui) handleToggleCommitFileDirCollapsed() error {
-	node := gui.getSelectedCommitFileNode()
-	if node == nil {
-		return nil
-	}
-
-	gui.State.CommitFileManager.ToggleCollapsed(node.GetPath())
-
-	if err := gui.postRefreshUpdate(gui.State.Contexts.CommitFiles); err != nil {
-		gui.Log.Error(err)
-	}
-
-	return nil
-}
-
 func (gui *Gui) switchToCommitFilesContext(refName string, canRebase bool, context Context, windowName string) error {
 	// sometimes the commitFiles view is already shown in another window, so we need to ensure that window
 	// no longer considers the commitFiles view as its main view.
-	gui.resetWindowForView(gui.Views.CommitFiles)
+	gui.resetWindowForView("commitFiles")

 	gui.State.Panels.CommitFiles.SelectedLineIdx = 0
 	gui.State.Panels.CommitFiles.refName = refName
 	gui.State.Panels.CommitFiles.canRebase = canRebase
-	gui.State.Contexts.CommitFiles.SetParentContext(context)
-	gui.State.Contexts.CommitFiles.SetWindowName(windowName)
+	gui.Contexts.CommitFiles.Context.SetParentContext(context)
+	gui.Contexts.CommitFiles.Context.SetWindowName(windowName)

 	if err := gui.refreshCommitFilesView(); err != nil {
 		return err
 	}

-	return gui.pushContext(gui.State.Contexts.CommitFiles)
-}
-
-// NOTE: this is very similar to handleToggleFileTreeView, could be DRY'd with generics
-func (gui *Gui) handleToggleCommitFileTreeView() error {
-	path := gui.getSelectedCommitFilePath()
-
-	gui.State.CommitFileManager.ToggleShowTree()
-
-	// find that same node in the new format and move the cursor to it
-	if path != "" {
-		gui.State.CommitFileManager.ExpandToPath(path)
-		index, found := gui.State.CommitFileManager.GetIndexForPath(path)
-		if found {
-			gui.State.Contexts.CommitFiles.GetPanelState().SetSelectedLineIdx(index)
-		}
-	}
-
-	if err := gui.State.Contexts.CommitFiles.HandleRender(); err != nil {
-		return err
-	}
-	if err := gui.State.Contexts.CommitFiles.HandleFocus(); err != nil {
-		return err
-	}
-
-	return nil
+	return gui.switchContext(gui.Contexts.CommitFiles.Context)
 }
@@ -1,16 +1,33 @@
 package gui

 import (
+	"os/exec"
 	"strconv"
 	"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())
+// runSyncOrAsyncCommand takes the output of a command that may have returned
+// either no error, an error, or a subprocess to execute, and if a subprocess
+// needs to be set on the gui object, it does so, and then returns the error
+// the bool returned tells us whether the calling code should continue
+func (gui *Gui) runSyncOrAsyncCommand(sub *exec.Cmd, err error) (bool, error) {
+	if err != nil {
+		if err != gui.Errors.ErrSubProcess {
+			return false, gui.surfaceError(err)
+		}
+	}
+	if sub != nil {
+		gui.SubProcess = sub
+		return false, gui.Errors.ErrSubProcess
+	}
+	return true, nil
+}
+
+func (gui *Gui) handleCommitConfirm(g *gocui.Gui, v *gocui.View) error {
+	message := gui.trimmedContent(v)
 	if message == "" {
 		return gui.createErrorPanel(gui.Tr.CommitWithoutMessageErr)
 	}
@@ -19,17 +36,20 @@ func (gui *Gui) handleCommitConfirm() error {
 	if skipHookPrefix != "" && strings.HasPrefix(message, skipHookPrefix) {
 		flags = "--no-verify"
 	}
-
-	cmdStr := gui.GitCommand.CommitCmdStr(message, flags)
-	gui.OnRunCommand(oscommands.NewCmdLogEntry(cmdStr, gui.Tr.Spans.Commit, true))
-	_ = gui.returnFromContext()
-	return gui.withGpgHandling(cmdStr, gui.Tr.CommittingStatus, func() error {
-		gui.Views.CommitMessage.ClearTextArea()
+	ok, err := gui.runSyncOrAsyncCommand(gui.GitCommand.Commit(message, flags))
+	if err != nil {
+		return err
+	}
+	if !ok {
 		return nil
-	})
+	}
+
+	gui.clearEditorView(v)
+	_ = gui.returnFromContext()
+	return gui.refreshSidePanels(refreshOptions{mode: ASYNC})
 }

-func (gui *Gui) handleCommitClose() error {
+func (gui *Gui) handleCommitClose(g *gocui.Gui, v *gocui.View) error {
 	return gui.returnFromContext()
 }

@@ -37,18 +57,18 @@ func (gui *Gui) handleCommitMessageFocused() error {
 	message := utils.ResolvePlaceholderString(
 		gui.Tr.CommitMessageConfirm,
 		map[string]string{
-			"keyBindClose":   gui.getKeyDisplay(gui.Config.GetUserConfig().Keybinding.Universal.Return),
-			"keyBindConfirm": gui.getKeyDisplay(gui.Config.GetUserConfig().Keybinding.Universal.Confirm),
-			"keyBindNewLine": gui.getKeyDisplay(gui.Config.GetUserConfig().Keybinding.Universal.AppendNewline),
+			"keyBindClose":   "esc",
+			"keyBindConfirm": "enter",
+			"keyBindNewLine": "tab",
 		},
 	)

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

 func (gui *Gui) getBufferLength(view *gocui.View) string {
-	return " " + strconv.Itoa(strings.Count(view.TextArea.GetContent(), "")-1) + " "
+	return " " + strconv.Itoa(strings.Count(view.Buffer(), "")-1) + " "
 }

 // RenderCommitLength is a function.
@@ -56,6 +76,46 @@ func (gui *Gui) RenderCommitLength() {
 	if !gui.Config.GetUserConfig().Gui.CommitLength.Show {
 		return
 	}
+	v := gui.getCommitMessageView()
+	v.Subtitle = gui.getBufferLength(v)
+}

-	gui.Views.CommitMessage.Subtitle = gui.getBufferLength(gui.Views.CommitMessage)
+// we've just copy+pasted the editor from gocui to here so that we can also re-
+// render the commit message length on each keypress
+func (gui *Gui) commitMessageEditor(v *gocui.View, key gocui.Key, ch rune, mod gocui.Modifier) {
+	newlineKey, ok := gui.getKey(gui.Config.GetUserConfig().Keybinding.Universal.AppendNewline).(gocui.Key)
+	if !ok {
+		newlineKey = gocui.KeyTab
+	}
+
+	switch {
+	case key == gocui.KeyBackspace || key == gocui.KeyBackspace2:
+		v.EditDelete(true)
+	case key == gocui.KeyDelete:
+		v.EditDelete(false)
+	case key == gocui.KeyArrowDown:
+		v.MoveCursor(0, 1, false)
+	case key == gocui.KeyArrowUp:
+		v.MoveCursor(0, -1, false)
+	case key == gocui.KeyArrowLeft:
+		v.MoveCursor(-1, 0, false)
+	case key == gocui.KeyArrowRight:
+		v.MoveCursor(1, 0, false)
+	case key == newlineKey:
+		v.EditNewLine()
+	case key == gocui.KeySpace:
+		v.EditWrite(' ')
+	case key == gocui.KeyInsert:
+		v.Overwrite = !v.Overwrite
+	case key == gocui.KeyCtrlU:
+		v.EditDeleteToStartOfLine()
+	case key == gocui.KeyCtrlA:
+		v.EditGotoToStartOfLine()
+	case key == gocui.KeyCtrlE:
+		v.EditGotoToEndOfLine()
+	default:
+		v.EditWrite(ch)
+	}
+
+	gui.RenderCommitLength()
 }
@@ -1,23 +1,19 @@
 package gui

 import (
-	"fmt"
 	"sync"

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

-// after selecting the 200th commit, we'll load in all the rest
-const COMMIT_THRESHOLD = 200
-
 // list panel functions

 func (gui *Gui) getSelectedLocalCommit() *models.Commit {
 	selectedLine := gui.State.Panels.Commits.SelectedLineIdx
-	if selectedLine == -1 || selectedLine > len(gui.State.Commits)-1 {
+	if selectedLine == -1 {
 		return nil
 	}

@@ -26,7 +22,7 @@ func (gui *Gui) getSelectedLocalCommit() *models.Commit {

 func (gui *Gui) handleCommitSelect() error {
 	state := gui.State.Panels.Commits
-	if state.SelectedLineIdx > COMMIT_THRESHOLD && state.LimitCommits {
+	if state.SelectedLineIdx > 290 && state.LimitCommits {
 		state.LimitCommits = false
 		go utils.Safe(func() {
 			if err := gui.refreshCommitsWithLimit(); err != nil {
@@ -40,12 +36,12 @@ func (gui *Gui) handleCommitSelect() error {
 	var task updateTask
 	commit := gui.getSelectedLocalCommit()
 	if commit == nil {
-		task = NewRenderStringTask(gui.Tr.NoCommitsThisBranch)
+		task = gui.createRenderStringTask(gui.Tr.NoCommitsThisBranch)
 	} else {
 		cmd := gui.OSCommand.ExecutableFromString(
-			gui.GitCommand.ShowCmdStr(commit.Sha, gui.State.Modes.Filtering.GetPath()),
+			gui.GitCommand.ShowCmdStr(commit.Sha, gui.State.Modes.Filtering.Path),
 		)
-		task = NewRunPtyTask(cmd)
+		task = gui.createRunPtyTask(cmd)
 	}

 	return gui.refreshMainViews(refreshMainOpts{
@@ -91,7 +87,7 @@ func (gui *Gui) refreshCommits() error {

 	go utils.Safe(func() {
 		_ = gui.refreshCommitsWithLimit()
-		context, ok := gui.State.Contexts.CommitFiles.GetParentContext()
+		context, ok := gui.Contexts.CommitFiles.Context.GetParentContext()
 		if ok && context.GetKey() == BRANCH_COMMITS_CONTEXT_KEY {
 			// This makes sense when we've e.g. just amended a commit, meaning we get a new commit SHA at the same position.
 			// However if we've just added a brand new commit, it pushes the list down by one and so we would end up
@@ -122,10 +118,9 @@ func (gui *Gui) refreshCommitsWithLimit() error {
 	commits, err := builder.GetCommits(
 		commands.GetCommitsOptions{
 			Limit:                gui.State.Panels.Commits.LimitCommits,
-			FilterPath:           gui.State.Modes.Filtering.GetPath(),
+			FilterPath:           gui.State.Modes.Filtering.Path,
 			IncludeRebaseCommits: true,
 			RefName:              "HEAD",
-			All:                  gui.State.ShowWholeGitGraph,
 		},
 	)
 	if err != nil {
@@ -133,7 +128,7 @@ func (gui *Gui) refreshCommitsWithLimit() error {
 	}
 	gui.State.Commits = commits

-	return gui.postRefreshUpdate(gui.State.Contexts.BranchCommits)
+	return gui.postRefreshUpdate(gui.Contexts.BranchCommits.Context)
 }

 func (gui *Gui) refreshRebaseCommits() error {
@@ -148,12 +143,12 @@ func (gui *Gui) refreshRebaseCommits() error {
 	}
 	gui.State.Commits = updatedCommits

-	return gui.postRefreshUpdate(gui.State.Contexts.BranchCommits)
+	return gui.postRefreshUpdate(gui.Contexts.BranchCommits.Context)
 }

 // specific functions

-func (gui *Gui) handleCommitSquashDown() error {
+func (gui *Gui) handleCommitSquashDown(g *gocui.Gui, v *gocui.View) error {
 	if ok, err := gui.validateNotInFilterMode(); err != nil || !ok {
 		return err
 	}
@@ -175,14 +170,14 @@ func (gui *Gui) handleCommitSquashDown() error {
 		prompt: gui.Tr.SureSquashThisCommit,
 		handleConfirm: func() error {
 			return gui.WithWaitingStatus(gui.Tr.SquashingStatus, func() error {
-				err := gui.GitCommand.WithSpan(gui.Tr.Spans.SquashCommitDown).InteractiveRebase(gui.State.Commits, gui.State.Panels.Commits.SelectedLineIdx, "squash")
+				err := gui.GitCommand.InteractiveRebase(gui.State.Commits, gui.State.Panels.Commits.SelectedLineIdx, "squash")
 				return gui.handleGenericMergeCommandResult(err)
 			})
 		},
 	})
 }

-func (gui *Gui) handleCommitFixup() error {
+func (gui *Gui) handleCommitFixup(g *gocui.Gui, v *gocui.View) error {
 	if ok, err := gui.validateNotInFilterMode(); err != nil || !ok {
 		return err
 	}
@@ -204,14 +199,14 @@ func (gui *Gui) handleCommitFixup() error {
 		prompt: gui.Tr.SureFixupThisCommit,
 		handleConfirm: func() error {
 			return gui.WithWaitingStatus(gui.Tr.FixingStatus, func() error {
-				err := gui.GitCommand.WithSpan(gui.Tr.Spans.FixupCommit).InteractiveRebase(gui.State.Commits, gui.State.Panels.Commits.SelectedLineIdx, "fixup")
+				err := gui.GitCommand.InteractiveRebase(gui.State.Commits, gui.State.Panels.Commits.SelectedLineIdx, "fixup")
 				return gui.handleGenericMergeCommandResult(err)
 			})
 		},
 	})
 }

-func (gui *Gui) handleRenameCommit() error {
+func (gui *Gui) handleRenameCommit(g *gocui.Gui, v *gocui.View) error {
 	if ok, err := gui.validateNotInFilterMode(); err != nil || !ok {
 		return err
 	}
@@ -238,20 +233,16 @@ func (gui *Gui) handleRenameCommit() error {
 		return gui.surfaceError(err)
 	}

-	return gui.prompt(promptOpts{
-		title:          gui.Tr.LcRenameCommit,
-		initialContent: message,
-		handleConfirm: func(response string) error {
-			if err := gui.GitCommand.WithSpan(gui.Tr.Spans.RewordCommit).RenameCommit(response); err != nil {
-				return gui.surfaceError(err)
-			}
+	return gui.prompt(gui.Tr.LcRenameCommit, message, func(response string) error {
+		if err := gui.GitCommand.RenameCommit(response); err != nil {
+			return gui.surfaceError(err)
+		}

-			return gui.refreshSidePanels(refreshOptions{mode: ASYNC})
-		},
+		return gui.refreshSidePanels(refreshOptions{mode: ASYNC})
 	})
 }

-func (gui *Gui) handleRenameCommitEditor() error {
+func (gui *Gui) handleRenameCommitEditor(g *gocui.Gui, v *gocui.View) error {
 	if ok, err := gui.validateNotInFilterMode(); err != nil || !ok {
 		return err
 	}
@@ -264,12 +255,13 @@ func (gui *Gui) handleRenameCommitEditor() error {
 		return nil
 	}

-	subProcess, err := gui.GitCommand.WithSpan(gui.Tr.Spans.RewordCommit).RewordCommit(gui.State.Commits, gui.State.Panels.Commits.SelectedLineIdx)
+	subProcess, err := gui.GitCommand.RewordCommit(gui.State.Commits, gui.State.Panels.Commits.SelectedLineIdx)
 	if err != nil {
 		return gui.surfaceError(err)
 	}
 	if subProcess != nil {
-		return gui.runSubprocessWithSuspenseAndRefresh(subProcess)
+		gui.SubProcess = subProcess
+		return gui.Errors.ErrSubProcess
 	}

 	return nil
@@ -292,12 +284,6 @@ func (gui *Gui) handleMidRebaseCommand(action string) (bool, error) {
 		return true, gui.createErrorPanel(gui.Tr.LcRewordNotSupported)
 	}

-	gui.OnRunCommand(oscommands.NewCmdLogEntry(
-		fmt.Sprintf("Updating rebase action of commit %s to '%s'", selectedCommit.ShortSha(), action),
-		"Update rebase TODO",
-		false,
-	))
-
 	if err := gui.GitCommand.EditRebaseTodo(gui.State.Panels.Commits.SelectedLineIdx, action); err != nil {
 		return false, gui.surfaceError(err)
 	}
@@ -305,7 +291,7 @@ func (gui *Gui) handleMidRebaseCommand(action string) (bool, error) {
 	return true, gui.refreshRebaseCommits()
 }

-func (gui *Gui) handleCommitDelete() error {
+func (gui *Gui) handleCommitDelete(g *gocui.Gui, v *gocui.View) error {
 	if ok, err := gui.validateNotInFilterMode(); err != nil || !ok {
 		return err
 	}
@@ -323,35 +309,24 @@ func (gui *Gui) handleCommitDelete() error {
 		prompt: gui.Tr.DeleteCommitPrompt,
 		handleConfirm: func() error {
 			return gui.WithWaitingStatus(gui.Tr.DeletingStatus, func() error {
-				err := gui.GitCommand.WithSpan(gui.Tr.Spans.DropCommit).InteractiveRebase(gui.State.Commits, gui.State.Panels.Commits.SelectedLineIdx, "drop")
+				err := gui.GitCommand.InteractiveRebase(gui.State.Commits, gui.State.Panels.Commits.SelectedLineIdx, "drop")
 				return gui.handleGenericMergeCommandResult(err)
 			})
 		},
 	})
 }

-func (gui *Gui) handleCommitMoveDown() error {
+func (gui *Gui) handleCommitMoveDown(g *gocui.Gui, v *gocui.View) error {
 	if ok, err := gui.validateNotInFilterMode(); err != nil || !ok {
 		return err
 	}

-	span := gui.Tr.Spans.MoveCommitDown
-
 	index := gui.State.Panels.Commits.SelectedLineIdx
 	selectedCommit := gui.State.Commits[index]
 	if selectedCommit.Status == "rebasing" {
 		if gui.State.Commits[index+1].Status != "rebasing" {
 			return nil
 		}
-
-		// logging directly here because MoveTodoDown doesn't have enough information
-		// to provide a useful log
-		gui.OnRunCommand(oscommands.NewCmdLogEntry(
-			fmt.Sprintf("Moving commit %s down", selectedCommit.ShortSha()),
-			span,
-			false,
-		))
-
 		if err := gui.GitCommand.MoveTodoDown(index); err != nil {
 			return gui.surfaceError(err)
 		}
@@ -360,7 +335,7 @@ func (gui *Gui) handleCommitMoveDown() error {
 	}

 	return gui.WithWaitingStatus(gui.Tr.MovingStatus, func() error {
-		err := gui.GitCommand.WithSpan(span).MoveCommitDown(gui.State.Commits, index)
+		err := gui.GitCommand.MoveCommitDown(gui.State.Commits, index)
 		if err == nil {
 			gui.State.Panels.Commits.SelectedLineIdx++
 		}
@@ -368,7 +343,7 @@ func (gui *Gui) handleCommitMoveDown() error {
 	})
 }

-func (gui *Gui) handleCommitMoveUp() error {
+func (gui *Gui) handleCommitMoveUp(g *gocui.Gui, v *gocui.View) error {
 	if ok, err := gui.validateNotInFilterMode(); err != nil || !ok {
 		return err
 	}
@@ -377,19 +352,8 @@ func (gui *Gui) handleCommitMoveUp() error {
 	if index == 0 {
 		return nil
 	}
-
-	span := gui.Tr.Spans.MoveCommitUp
-
 	selectedCommit := gui.State.Commits[index]
 	if selectedCommit.Status == "rebasing" {
-		// logging directly here because MoveTodoDown doesn't have enough information
-		// to provide a useful log
-		gui.OnRunCommand(oscommands.NewCmdLogEntry(
-			fmt.Sprintf("Moving commit %s up", selectedCommit.ShortSha()),
-			span,
-			false,
-		))
-
 		if err := gui.GitCommand.MoveTodoDown(index - 1); err != nil {
 			return gui.surfaceError(err)
 		}
@@ -398,7 +362,7 @@ func (gui *Gui) handleCommitMoveUp() error {
 	}

 	return gui.WithWaitingStatus(gui.Tr.MovingStatus, func() error {
-		err := gui.GitCommand.WithSpan(span).MoveCommitDown(gui.State.Commits, index-1)
+		err := gui.GitCommand.MoveCommitDown(gui.State.Commits, index-1)
 		if err == nil {
 			gui.State.Panels.Commits.SelectedLineIdx--
 		}
@@ -406,7 +370,7 @@ func (gui *Gui) handleCommitMoveUp() error {
 	})
 }

-func (gui *Gui) handleCommitEdit() error {
+func (gui *Gui) handleCommitEdit(g *gocui.Gui, v *gocui.View) error {
 	if ok, err := gui.validateNotInFilterMode(); err != nil || !ok {
 		return err
 	}
@@ -420,12 +384,12 @@ func (gui *Gui) handleCommitEdit() error {
 	}

 	return gui.WithWaitingStatus(gui.Tr.RebasingStatus, func() error {
-		err = gui.GitCommand.WithSpan(gui.Tr.Spans.EditCommit).InteractiveRebase(gui.State.Commits, gui.State.Panels.Commits.SelectedLineIdx, "edit")
+		err = gui.GitCommand.InteractiveRebase(gui.State.Commits, gui.State.Panels.Commits.SelectedLineIdx, "edit")
 		return gui.handleGenericMergeCommandResult(err)
 	})
 }

-func (gui *Gui) handleCommitAmendTo() error {
+func (gui *Gui) handleCommitAmendTo(g *gocui.Gui, v *gocui.View) error {
 	if ok, err := gui.validateNotInFilterMode(); err != nil || !ok {
 		return err
 	}
@@ -435,14 +399,14 @@ func (gui *Gui) handleCommitAmendTo() error {
 		prompt: gui.Tr.AmendCommitPrompt,
 		handleConfirm: func() error {
 			return gui.WithWaitingStatus(gui.Tr.AmendingStatus, func() error {
-				err := gui.GitCommand.WithSpan(gui.Tr.Spans.AmendCommit).AmendTo(gui.State.Commits[gui.State.Panels.Commits.SelectedLineIdx].Sha)
+				err := gui.GitCommand.AmendTo(gui.State.Commits[gui.State.Panels.Commits.SelectedLineIdx].Sha)
 				return gui.handleGenericMergeCommandResult(err)
 			})
 		},
 	})
 }

-func (gui *Gui) handleCommitPick() error {
+func (gui *Gui) handleCommitPick(g *gocui.Gui, v *gocui.View) error {
 	if ok, err := gui.validateNotInFilterMode(); err != nil || !ok {
 		return err
 	}
@@ -457,53 +421,19 @@ func (gui *Gui) handleCommitPick() error {

 	// at this point we aren't actually rebasing so we will interpret this as an
 	// attempt to pull. We might revoke this later after enabling configurable keybindings
-	return gui.handlePullFiles()
+	return gui.handlePullFiles(g, v)
 }

-func (gui *Gui) handleCommitRevert() error {
+func (gui *Gui) handleCommitRevert(g *gocui.Gui, v *gocui.View) error {
 	if ok, err := gui.validateNotInFilterMode(); err != nil || !ok {
 		return err
 	}

-	commit := gui.getSelectedLocalCommit()
-
-	if commit.IsMerge() {
-		return gui.createRevertMergeCommitMenu(commit)
-	} else {
-		if err := gui.GitCommand.WithSpan(gui.Tr.Spans.RevertCommit).Revert(commit.Sha); err != nil {
-			return gui.surfaceError(err)
-		}
-		return gui.afterRevertCommit()
+	if err := gui.GitCommand.Revert(gui.State.Commits[gui.State.Panels.Commits.SelectedLineIdx].Sha); err != nil {
+		return gui.surfaceError(err)
 	}
-}
-
-func (gui *Gui) createRevertMergeCommitMenu(commit *models.Commit) error {
-	menuItems := make([]*menuItem, len(commit.Parents))
-	for i, parentSha := range commit.Parents {
-		i := i
-		message, err := gui.GitCommand.GetCommitMessageFirstLine(parentSha)
-		if err != nil {
-			return gui.surfaceError(err)
-		}
-
-		menuItems[i] = &menuItem{
-			displayString: fmt.Sprintf("%s: %s", utils.SafeTruncate(parentSha, 8), message),
-			onPress: func() error {
-				parentNumber := i + 1
-				if err := gui.GitCommand.WithSpan(gui.Tr.Spans.RevertCommit).RevertMerge(commit.Sha, parentNumber); err != nil {
-					return gui.surfaceError(err)
-				}
-				return gui.afterRevertCommit()
-			},
-		}
-	}
-
-	return gui.createMenu(gui.Tr.SelectParentCommitForMerge, menuItems, createMenuOptions{showCancel: true})
-}
-
-func (gui *Gui) afterRevertCommit() error {
 	gui.State.Panels.Commits.SelectedLineIdx++
-	return gui.refreshSidePanels(refreshOptions{mode: BLOCK_UI, scope: []RefreshableView{COMMITS, BRANCHES}})
+	return gui.refreshSidePanels(refreshOptions{mode: BLOCK_UI, scope: []int{COMMITS, BRANCHES}})
 }

 func (gui *Gui) handleViewCommitFiles() error {
@@ -512,10 +442,23 @@ func (gui *Gui) handleViewCommitFiles() error {
 		return nil
 	}

-	return gui.switchToCommitFilesContext(commit.Sha, true, gui.State.Contexts.BranchCommits, "commits")
+	return gui.switchToCommitFilesContext(commit.Sha, true, gui.Contexts.BranchCommits.Context, "commits")
 }

-func (gui *Gui) handleCreateFixupCommit() error {
+func (gui *Gui) hasCommit(commits []*models.Commit, target string) (int, bool) {
+	for idx, commit := range commits {
+		if commit.Sha == target {
+			return idx, true
+		}
+	}
+	return -1, false
+}
+
+func (gui *Gui) unchooseCommit(commits []*models.Commit, i int) []*models.Commit {
+	return append(commits[:i], commits[i+1:]...)
+}
+
+func (gui *Gui) handleCreateFixupCommit(g *gocui.Gui, v *gocui.View) error {
 	if ok, err := gui.validateNotInFilterMode(); err != nil || !ok {
 		return err
 	}
@@ -536,7 +479,7 @@ func (gui *Gui) handleCreateFixupCommit() error {
 		title:  gui.Tr.CreateFixupCommit,
 		prompt: prompt,
 		handleConfirm: func() error {
-			if err := gui.GitCommand.WithSpan(gui.Tr.Spans.CreateFixupCommit).CreateFixupCommit(commit.Sha); err != nil {
+			if err := gui.GitCommand.CreateFixupCommit(commit.Sha); err != nil {
 				return gui.surfaceError(err)
 			}

@@ -545,7 +488,7 @@ func (gui *Gui) handleCreateFixupCommit() error {
 	})
 }

-func (gui *Gui) handleSquashAllAboveFixupCommits() error {
+func (gui *Gui) handleSquashAllAboveFixupCommits(g *gocui.Gui, v *gocui.View) error {
 	if ok, err := gui.validateNotInFilterMode(); err != nil || !ok {
 		return err
 	}
@@ -567,14 +510,14 @@ func (gui *Gui) handleSquashAllAboveFixupCommits() error {
 		prompt: prompt,
 		handleConfirm: func() error {
 			return gui.WithWaitingStatus(gui.Tr.SquashingStatus, func() error {
-				err := gui.GitCommand.WithSpan(gui.Tr.Spans.SquashAllAboveFixupCommits).SquashAllAboveFixupCommits(commit.Sha)
+				err := gui.GitCommand.SquashAllAboveFixupCommits(commit.Sha)
 				return gui.handleGenericMergeCommandResult(err)
 			})
 		},
 	})
 }

-func (gui *Gui) handleTagCommit() error {
+func (gui *Gui) handleTagCommit(g *gocui.Gui, v *gocui.View) error {
 	// TODO: bring up menu asking if you want to make a lightweight or annotated tag
 	// if annotated, switch to a subprocess to create the message

@@ -587,18 +530,15 @@ func (gui *Gui) handleTagCommit() error {
 }

 func (gui *Gui) handleCreateLightweightTag(commitSha string) error {
-	return gui.prompt(promptOpts{
-		title: gui.Tr.TagNameTitle,
-		handleConfirm: func(response string) error {
-			if err := gui.GitCommand.WithSpan(gui.Tr.Spans.CreateLightweightTag).CreateLightweightTag(response, commitSha); err != nil {
-				return gui.surfaceError(err)
-			}
-			return gui.refreshSidePanels(refreshOptions{mode: ASYNC, scope: []RefreshableView{COMMITS, TAGS}})
-		},
+	return gui.prompt(gui.Tr.TagNameTitle, "", func(response string) error {
+		if err := gui.GitCommand.CreateLightweightTag(response, commitSha); err != nil {
+			return gui.surfaceError(err)
+		}
+		return gui.refreshSidePanels(refreshOptions{mode: ASYNC, scope: []int{COMMITS, TAGS}})
 	})
 }

-func (gui *Gui) handleCheckoutCommit() error {
+func (gui *Gui) handleCheckoutCommit(g *gocui.Gui, v *gocui.View) error {
 	commit := gui.getSelectedLocalCommit()
 	if commit == nil {
 		return nil
@@ -608,12 +548,12 @@ func (gui *Gui) handleCheckoutCommit() error {
 		title:  gui.Tr.LcCheckoutCommit,
 		prompt: gui.Tr.SureCheckoutThisCommit,
 		handleConfirm: func() error {
-			return gui.handleCheckoutRef(commit.Sha, handleCheckoutRefOptions{span: gui.Tr.Spans.CheckoutCommit})
+			return gui.handleCheckoutRef(commit.Sha, handleCheckoutRefOptions{})
 		},
 	})
 }

-func (gui *Gui) handleCreateCommitResetMenu() error {
+func (gui *Gui) handleCreateCommitResetMenu(g *gocui.Gui, v *gocui.View) error {
 	commit := gui.getSelectedLocalCommit()
 	if commit == nil {
 		return gui.createErrorPanel(gui.Tr.NoCommitsThisBranch)
@@ -622,30 +562,30 @@ func (gui *Gui) handleCreateCommitResetMenu() error {
 	return gui.createResetMenu(commit.Sha)
 }

-func (gui *Gui) handleOpenSearchForCommitsPanel(_viewName string) error {
+func (gui *Gui) handleOpenSearchForCommitsPanel(g *gocui.Gui, v *gocui.View) error {
 	// we usually lazyload these commits but now that we're searching we need to load them now
 	if gui.State.Panels.Commits.LimitCommits {
 		gui.State.Panels.Commits.LimitCommits = false
-		if err := gui.refreshSidePanels(refreshOptions{mode: ASYNC, scope: []RefreshableView{COMMITS}}); err != nil {
+		if err := gui.refreshSidePanels(refreshOptions{mode: ASYNC, scope: []int{COMMITS}}); err != nil {
 			return err
 		}
 	}

-	return gui.handleOpenSearch("commits")
+	return gui.handleOpenSearch(gui.g, v)
 }

-func (gui *Gui) handleGotoBottomForCommitsPanel() error {
+func (gui *Gui) handleGotoBottomForCommitsPanel(g *gocui.Gui, v *gocui.View) error {
 	// we usually lazyload these commits but now that we're searching we need to load them now
 	if gui.State.Panels.Commits.LimitCommits {
 		gui.State.Panels.Commits.LimitCommits = false
-		if err := gui.refreshSidePanels(refreshOptions{mode: SYNC, scope: []RefreshableView{COMMITS}}); err != nil {
+		if err := gui.refreshSidePanels(refreshOptions{mode: SYNC, scope: []int{COMMITS}}); err != nil {
 			return err
 		}
 	}

 	for _, context := range gui.getListContexts() {
-		if context.GetViewName() == "commits" {
-			return context.handleGotoBottom()
+		if context.ViewName == "commits" {
+			return context.handleGotoBottom(g, v)
 		}
 	}

@@ -662,96 +602,5 @@ func (gui *Gui) handleCopySelectedCommitMessageToClipboard() error {
 	if err != nil {
 		return gui.surfaceError(err)
 	}
-
-	if err := gui.OSCommand.WithSpan(gui.Tr.Spans.CopyCommitMessageToClipboard).CopyToClipboard(message); err != nil {
-		return gui.surfaceError(err)
-	}
-
-	gui.raiseToast(gui.Tr.CommitMessageCopiedToClipboard)
-
-	return nil
-}
-
-func (gui *Gui) handleOpenLogMenu() error {
-	return gui.createMenu(gui.Tr.LogMenuTitle, []*menuItem{
-		{
-			displayString: gui.Tr.ToggleShowGitGraphAll,
-			onPress: func() error {
-				gui.State.ShowWholeGitGraph = !gui.State.ShowWholeGitGraph
-
-				if gui.State.ShowWholeGitGraph {
-					gui.State.Panels.Commits.LimitCommits = false
-				}
-
-				return gui.WithWaitingStatus(gui.Tr.LcLoadingCommits, func() error {
-					return gui.refreshSidePanels(refreshOptions{mode: SYNC, scope: []RefreshableView{COMMITS}})
-				})
-			},
-		},
-		{
-			displayString: gui.Tr.ShowGitGraph,
-			opensMenu:     true,
-			onPress: func() error {
-				onSelect := func(value string) {
-					gui.Config.GetUserConfig().Git.Log.ShowGraph = value
-					gui.render()
-				}
-				return gui.createMenu(gui.Tr.LogMenuTitle, []*menuItem{
-					{
-						displayString: "always",
-						onPress: func() error {
-							onSelect("always")
-							return nil
-						},
-					},
-					{
-						displayString: "never",
-						onPress: func() error {
-							onSelect("never")
-							return nil
-						},
-					},
-					{
-						displayString: "when maximised",
-						onPress: func() error {
-							onSelect("when-maximised")
-							return nil
-						},
-					},
-				}, createMenuOptions{showCancel: true})
-			},
-		},
-		{
-			displayString: gui.Tr.SortCommits,
-			opensMenu:     true,
-			onPress: func() error {
-				onSelect := func(value string) error {
-					gui.Config.GetUserConfig().Git.Log.Order = value
-					return gui.WithWaitingStatus(gui.Tr.LcLoadingCommits, func() error {
-						return gui.refreshSidePanels(refreshOptions{mode: SYNC, scope: []RefreshableView{COMMITS}})
-					})
-				}
-				return gui.createMenu(gui.Tr.LogMenuTitle, []*menuItem{
-					{
-						displayString: "topological (topo-order)",
-						onPress: func() error {
-							return onSelect("topo-order")
-						},
-					},
-					{
-						displayString: "date-order",
-						onPress: func() error {
-							return onSelect("date-order")
-						},
-					},
-					{
-						displayString: "author-date-order",
-						onPress: func() error {
-							return onSelect("author-date-order")
-						},
-					},
-				}, createMenuOptions{showCancel: true})
-			},
-		},
-	}, createMenuOptions{showCancel: true})
+	return gui.OSCommand.CopyToClipboard(message)
 }
@@ -1,14 +1,17 @@
 // lots of this has been directly ported from one of the example files, will brush up later

+// Copyright 2014 The gocui Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
 package gui

 import (
-	"fmt"
 	"strings"
+	"time"

+	"github.com/fatih/color"
 	"github.com/jesseduffield/gocui"
-	"github.com/jesseduffield/lazygit/pkg/gui/style"
-	"github.com/jesseduffield/lazygit/pkg/gui/types"
 	"github.com/jesseduffield/lazygit/pkg/theme"
 	"github.com/jesseduffield/lazygit/pkg/utils"
 )
@@ -24,8 +27,6 @@ type createPopupPanelOpts struct {

 	// when handlersManageFocus is true, do not return from the confirmation context automatically. It's expected that the handlers will manage focus, whether that means switching to another context, or manually returning the context.
 	handlersManageFocus bool
-
-	findSuggestionsFunc func(string) []*types.Suggestion
 }

 type askOpts struct {
@@ -36,11 +37,11 @@ type askOpts struct {
 	handlersManageFocus bool
 }

-type promptOpts struct {
-	title               string
-	initialContent      string
-	handleConfirm       func(string) error
-	findSuggestionsFunc func(string) []*types.Suggestion
+func (gui *Gui) createLoaderPanel(currentView *gocui.View, prompt string) error {
+	return gui.createPopupPanel(createPopupPanelOpts{
+		prompt:    prompt,
+		hasLoader: true,
+	})
 }

 func (gui *Gui) ask(opts askOpts) error {
@@ -53,25 +54,17 @@ func (gui *Gui) ask(opts askOpts) error {
 	})
 }

-func (gui *Gui) prompt(opts promptOpts) error {
+func (gui *Gui) prompt(title string, initialContent string, handleConfirm func(string) error) error {
 	return gui.createPopupPanel(createPopupPanelOpts{
-		title:               opts.title,
-		prompt:              opts.initialContent,
+		title:               title,
+		prompt:              initialContent,
 		editable:            true,
-		handleConfirmPrompt: opts.handleConfirm,
-		findSuggestionsFunc: opts.findSuggestionsFunc,
+		handleConfirmPrompt: handleConfirm,
 	})
 }

-func (gui *Gui) createLoaderPanel(prompt string) error {
-	return gui.createPopupPanel(createPopupPanelOpts{
-		prompt:    prompt,
-		hasLoader: true,
-	})
-}
-
-func (gui *Gui) wrappedConfirmationFunction(handlersManageFocus bool, function func() error) func() error {
-	return func() error {
+func (gui *Gui) wrappedConfirmationFunction(handlersManageFocus bool, function func() error) func(*gocui.Gui, *gocui.View) error {
+	return func(g *gocui.Gui, v *gocui.View) error {
 		if function != nil {
 			if err := function(); err != nil {
 				return err
@@ -86,10 +79,10 @@ func (gui *Gui) wrappedConfirmationFunction(handlersManageFocus bool, function f
 	}
 }

-func (gui *Gui) wrappedPromptConfirmationFunction(handlersManageFocus bool, function func(string) error, getResponse func() string) func() error {
-	return func() error {
+func (gui *Gui) wrappedPromptConfirmationFunction(handlersManageFocus bool, function func(string) error) func(*gocui.Gui, *gocui.View) error {
+	return func(g *gocui.Gui, v *gocui.View) error {
 		if function != nil {
-			if err := function(getResponse()); err != nil {
+			if err := function(v.Buffer()); err != nil {
 				return gui.surfaceError(err)
 			}
 		}
@@ -102,10 +95,19 @@ func (gui *Gui) wrappedPromptConfirmationFunction(handlersManageFocus bool, func
 	}
 }

+func (gui *Gui) deleteConfirmationView() {
+	keybindingConfig := gui.Config.GetUserConfig().Keybinding
+	_ = gui.g.DeleteKeybinding("confirmation", gui.getKey(keybindingConfig.Universal.Confirm), gocui.ModNone)
+	_ = gui.g.DeleteKeybinding("confirmation", gui.getKey(keybindingConfig.Universal.ConfirmAlt1), gocui.ModNone)
+	_ = gui.g.DeleteKeybinding("confirmation", gui.getKey(keybindingConfig.Universal.Return), gocui.ModNone)
+
+	_ = gui.g.DeleteView("confirmation")
+}
+
 func (gui *Gui) closeConfirmationPrompt(handlersManageFocus bool) error {
-	// we've already closed it so we can just return
-	if !gui.Views.Confirmation.Visible {
-		return nil
+	view := gui.getConfirmationView()
+	if view == nil {
+		return nil // if it's already been closed we can just return
 	}

 	if !handlersManageFocus {
@@ -114,10 +116,7 @@ func (gui *Gui) closeConfirmationPrompt(handlersManageFocus bool) error {
 		}
 	}

-	gui.clearConfirmationViewKeyBindings()
-	gui.Views.Confirmation.Visible = false
-	gui.Views.Suggestions.Visible = false
-
+	gui.deleteConfirmationView()
 	return nil
 }

@@ -157,79 +156,50 @@ func (gui *Gui) getConfirmationPanelDimensions(wrap bool, prompt string) (int, i
 		height/2 + panelHeight/2
 }

-func (gui *Gui) prepareConfirmationPanel(
-	title,
-	prompt string,
-	hasLoader bool,
-	findSuggestionsFunc func(string) []*types.Suggestion,
-	editable bool,
-) error {
+func (gui *Gui) prepareConfirmationPanel(title, prompt string, hasLoader bool) (*gocui.View, error) {
 	x0, y0, x1, y1 := gui.getConfirmationPanelDimensions(true, prompt)
-	// calling SetView on an existing view returns the same view, so I'm not bothering
-	// to reassign to gui.Views.Confirmation
-	_, err := gui.g.SetView("confirmation", x0, y0, x1, y1, 0)
+	confirmationView, err := gui.g.SetView("confirmation", x0, y0, x1, y1, 0)
 	if err != nil {
-		return err
-	}
-	gui.Views.Confirmation.HasLoader = hasLoader
-	if hasLoader {
-		gui.g.StartTicking()
-	}
-	gui.Views.Confirmation.Title = title
-	// for now we do not support wrapping in our editor
-	gui.Views.Confirmation.Wrap = !editable
-	gui.Views.Confirmation.FgColor = theme.GocuiDefaultTextColor
-
-	gui.findSuggestions = findSuggestionsFunc
-	if findSuggestionsFunc != nil {
-		suggestionsViewHeight := 11
-		suggestionsView, err := gui.g.SetView("suggestions", x0, y1+1, x1, y1+suggestionsViewHeight, 0)
-		if err != nil {
-			return err
+		if err.Error() != "unknown view" {
+			return nil, err
 		}
-		suggestionsView.Wrap = false
-		suggestionsView.FgColor = theme.GocuiDefaultTextColor
-		gui.setSuggestions(findSuggestionsFunc(""))
-		suggestionsView.Visible = true
-		suggestionsView.Title = fmt.Sprintf(gui.Tr.SuggestionsTitle, gui.Config.GetUserConfig().Keybinding.Universal.TogglePanel)
+		confirmationView.HasLoader = hasLoader
+		if hasLoader {
+			gui.g.StartTicking()
+		}
+		confirmationView.Title = title
+		confirmationView.Wrap = true
+		confirmationView.FgColor = theme.GocuiDefaultTextColor
 	}
-
 	gui.g.Update(func(g *gocui.Gui) error {
-		return gui.pushContext(gui.State.Contexts.Confirmation)
+		return gui.switchContext(gui.Contexts.Confirmation.Context)
 	})
-	return nil
+	return confirmationView, nil
 }

 func (gui *Gui) createPopupPanel(opts createPopupPanelOpts) error {
 	gui.g.Update(func(g *gocui.Gui) error {
-		// remove any previous keybindings
-		gui.clearConfirmationViewKeyBindings()
-
-		err := gui.prepareConfirmationPanel(
-			opts.title,
-			opts.prompt,
-			opts.hasLoader,
-			opts.findSuggestionsFunc,
-			opts.editable,
-		)
+		// delete the existing confirmation panel if it exists
+		if view, _ := g.View("confirmation"); view != nil {
+			gui.deleteConfirmationView()
+		}
+		confirmationView, err := gui.prepareConfirmationPanel(opts.title, opts.prompt, opts.hasLoader)
 		if err != nil {
 			return err
 		}
-		confirmationView := gui.Views.Confirmation
 		confirmationView.Editable = opts.editable
-		confirmationView.Editor = gocui.EditorFunc(gui.defaultEditor)
-
 		if opts.editable {
-			textArea := confirmationView.TextArea
-			textArea.Clear()
-			textArea.TypeString(opts.prompt)
-			confirmationView.RenderTextArea()
-		} else {
-			if err := gui.renderStringSync(confirmationView, opts.prompt); err != nil {
-				return err
-			}
+			go utils.Safe(func() {
+				// TODO: remove this wait (right now if you remove it the EditGotoToEndOfLine method doesn't seem to work)
+				time.Sleep(time.Millisecond)
+				gui.g.Update(func(g *gocui.Gui) error {
+					confirmationView.EditGotoToEndOfLine()
+					return nil
+				})
+			})
 		}

+		gui.renderString("confirmation", opts.prompt)
 		return gui.setKeyBindings(opts)
 	})
 	return nil
@@ -244,102 +214,28 @@ func (gui *Gui) setKeyBindings(opts createPopupPanelOpts) error {
 		},
 	)

-	gui.renderString(gui.Views.Options, actions)
-	var onConfirm func() error
+	gui.renderString("options", actions)
+	var onConfirm func(*gocui.Gui, *gocui.View) error
 	if opts.handleConfirmPrompt != nil {
-		onConfirm = gui.wrappedPromptConfirmationFunction(opts.handlersManageFocus, opts.handleConfirmPrompt, func() string { return gui.Views.Confirmation.TextArea.GetContent() })
+		onConfirm = gui.wrappedPromptConfirmationFunction(opts.handlersManageFocus, opts.handleConfirmPrompt)
 	} else {
 		onConfirm = gui.wrappedConfirmationFunction(opts.handlersManageFocus, opts.handleConfirm)
 	}

-	type confirmationKeybinding struct {
-		viewName string
-		key      interface{}
-		handler  func() error
-	}
-
 	keybindingConfig := gui.Config.GetUserConfig().Keybinding
-	onSuggestionConfirm := gui.wrappedPromptConfirmationFunction(
-		opts.handlersManageFocus,
-		opts.handleConfirmPrompt,
-		gui.getSelectedSuggestionValue,
-	)
-
-	confirmationKeybindings := []confirmationKeybinding{
-		{
-			viewName: "confirmation",
-			key:      gui.getKey(keybindingConfig.Universal.Confirm),
-			handler:  onConfirm,
-		},
-		{
-			viewName: "confirmation",
-			key:      gui.getKey(keybindingConfig.Universal.ConfirmAlt1),
-			handler:  onConfirm,
-		},
-		{
-			viewName: "confirmation",
-			key:      gui.getKey(keybindingConfig.Universal.Return),
-			handler:  gui.wrappedConfirmationFunction(opts.handlersManageFocus, opts.handleClose),
-		},
-		{
-			viewName: "confirmation",
-			key:      gui.getKey(keybindingConfig.Universal.TogglePanel),
-			handler: func() error {
-				if len(gui.State.Suggestions) > 0 {
-					return gui.replaceContext(gui.State.Contexts.Suggestions)
-				}
-				return nil
-			},
-		},
-		{
-			viewName: "suggestions",
-			key:      gui.getKey(keybindingConfig.Universal.Confirm),
-			handler:  onSuggestionConfirm,
-		},
-		{
-			viewName: "suggestions",
-			key:      gui.getKey(keybindingConfig.Universal.ConfirmAlt1),
-			handler:  onSuggestionConfirm,
-		},
-		{
-			viewName: "suggestions",
-			key:      gui.getKey(keybindingConfig.Universal.Return),
-			handler:  gui.wrappedConfirmationFunction(opts.handlersManageFocus, opts.handleClose),
-		},
-		{
-			viewName: "suggestions",
-			key:      gui.getKey(keybindingConfig.Universal.TogglePanel),
-			handler:  func() error { return gui.replaceContext(gui.State.Contexts.Confirmation) },
-		},
+	if err := gui.g.SetKeybinding("confirmation", nil, gui.getKey(keybindingConfig.Universal.Confirm), gocui.ModNone, onConfirm); err != nil {
+		return err
+	}
+	if err := gui.g.SetKeybinding("confirmation", nil, gui.getKey(keybindingConfig.Universal.ConfirmAlt1), gocui.ModNone, onConfirm); err != nil {
+		return err
 	}

-	for _, binding := range confirmationKeybindings {
-		if err := gui.g.SetKeybinding(binding.viewName, nil, binding.key, gocui.ModNone, gui.wrappedHandler(binding.handler)); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (gui *Gui) clearConfirmationViewKeyBindings() {
-	keybindingConfig := gui.Config.GetUserConfig().Keybinding
-	_ = gui.g.DeleteKeybinding("confirmation", gui.getKey(keybindingConfig.Universal.Confirm), gocui.ModNone)
-	_ = gui.g.DeleteKeybinding("confirmation", gui.getKey(keybindingConfig.Universal.ConfirmAlt1), gocui.ModNone)
-	_ = gui.g.DeleteKeybinding("confirmation", gui.getKey(keybindingConfig.Universal.Return), gocui.ModNone)
-	_ = gui.g.DeleteKeybinding("suggestions", gui.getKey(keybindingConfig.Universal.Confirm), gocui.ModNone)
-	_ = gui.g.DeleteKeybinding("suggestions", gui.getKey(keybindingConfig.Universal.ConfirmAlt1), gocui.ModNone)
-	_ = gui.g.DeleteKeybinding("suggestions", gui.getKey(keybindingConfig.Universal.Return), gocui.ModNone)
-}
-
-func (gui *Gui) wrappedHandler(f func() error) func(g *gocui.Gui, v *gocui.View) error {
-	return func(g *gocui.Gui, v *gocui.View) error {
-		return f()
-	}
+	return gui.g.SetKeybinding("confirmation", nil, gui.getKey(keybindingConfig.Universal.Return), gocui.ModNone, gui.wrappedConfirmationFunction(opts.handlersManageFocus, opts.handleClose))
 }

 func (gui *Gui) createErrorPanel(message string) error {
-	coloredMessage := style.FgRed.Sprint(strings.TrimSpace(message))
+	colorFunction := color.New(color.FgRed).SprintFunc()
+	coloredMessage := colorFunction(strings.TrimSpace(message))
 	if err := gui.refreshSidePanels(refreshOptions{mode: ASYNC}); err != nil {
 		return err
 	}
@@ -355,5 +251,11 @@ func (gui *Gui) surfaceError(err error) error {
 		return nil
 	}

+	for _, sentinelError := range gui.sentinelErrorsArr() {
+		if err == sentinelError {
+			return err
+		}
+	}
+
 	return gui.createErrorPanel(err.Error())
 }
@@ -6,25 +6,127 @@ import (
 	"github.com/jesseduffield/gocui"
 )

-type ContextKind int
-
 const (
-	SIDE_CONTEXT ContextKind = iota
+	SIDE_CONTEXT int = iota
 	MAIN_CONTEXT
 	TEMPORARY_POPUP
 	PERSISTENT_POPUP
-	EXTRAS_CONTEXT
 )

+const (
+	STATUS_CONTEXT_KEY              = "status"
+	FILES_CONTEXT_KEY               = "files"
+	LOCAL_BRANCHES_CONTEXT_KEY      = "localBranches"
+	REMOTES_CONTEXT_KEY             = "remotes"
+	REMOTE_BRANCHES_CONTEXT_KEY     = "remoteBranches"
+	TAGS_CONTEXT_KEY                = "tags"
+	BRANCH_COMMITS_CONTEXT_KEY      = "commits"
+	REFLOG_COMMITS_CONTEXT_KEY      = "reflogCommits"
+	SUB_COMMITS_CONTEXT_KEY         = "subCommits"
+	COMMIT_FILES_CONTEXT_KEY        = "commitFiles"
+	STASH_CONTEXT_KEY               = "stash"
+	MAIN_NORMAL_CONTEXT_KEY         = "normal"
+	MAIN_MERGING_CONTEXT_KEY        = "merging"
+	MAIN_PATCH_BUILDING_CONTEXT_KEY = "patchBuilding"
+	MAIN_STAGING_CONTEXT_KEY        = "staging"
+	MENU_CONTEXT_KEY                = "menu"
+	CREDENTIALS_CONTEXT_KEY         = "credentials"
+	CONFIRMATION_CONTEXT_KEY        = "confirmation"
+	SEARCH_CONTEXT_KEY              = "search"
+	COMMIT_MESSAGE_CONTEXT_KEY      = "commitMessage"
+	SUBMODULES_CONTEXT_KEY          = "submodules"
+)
+
+var allContextKeys = []string{
+	STATUS_CONTEXT_KEY,
+	FILES_CONTEXT_KEY,
+	LOCAL_BRANCHES_CONTEXT_KEY,
+	REMOTES_CONTEXT_KEY,
+	REMOTE_BRANCHES_CONTEXT_KEY,
+	TAGS_CONTEXT_KEY,
+	BRANCH_COMMITS_CONTEXT_KEY,
+	REFLOG_COMMITS_CONTEXT_KEY,
+	SUB_COMMITS_CONTEXT_KEY,
+	COMMIT_FILES_CONTEXT_KEY,
+	STASH_CONTEXT_KEY,
+	MAIN_NORMAL_CONTEXT_KEY,
+	MAIN_MERGING_CONTEXT_KEY,
+	MAIN_PATCH_BUILDING_CONTEXT_KEY,
+	MAIN_STAGING_CONTEXT_KEY,
+	MENU_CONTEXT_KEY,
+	CREDENTIALS_CONTEXT_KEY,
+	CONFIRMATION_CONTEXT_KEY,
+	SEARCH_CONTEXT_KEY,
+	COMMIT_MESSAGE_CONTEXT_KEY,
+	SUBMODULES_CONTEXT_KEY,
+}
+
+type SimpleContextNode struct {
+	Context Context
+}
+
+type RemotesContextNode struct {
+	Context  Context
+	Branches SimpleContextNode
+}
+
+type ContextTree struct {
+	Status        SimpleContextNode
+	Files         SimpleContextNode
+	Submodules    SimpleContextNode
+	Menu          SimpleContextNode
+	Branches      SimpleContextNode
+	Remotes       RemotesContextNode
+	Tags          SimpleContextNode
+	BranchCommits SimpleContextNode
+	CommitFiles   SimpleContextNode
+	ReflogCommits SimpleContextNode
+	SubCommits    SimpleContextNode
+	Stash         SimpleContextNode
+	Normal        SimpleContextNode
+	Staging       SimpleContextNode
+	PatchBuilding SimpleContextNode
+	Merging       SimpleContextNode
+	Credentials   SimpleContextNode
+	Confirmation  SimpleContextNode
+	CommitMessage SimpleContextNode
+	Search        SimpleContextNode
+}
+
+func (gui *Gui) allContexts() []Context {
+	return []Context{
+		gui.Contexts.Status.Context,
+		gui.Contexts.Files.Context,
+		gui.Contexts.Submodules.Context,
+		gui.Contexts.Branches.Context,
+		gui.Contexts.Remotes.Context,
+		gui.Contexts.Remotes.Branches.Context,
+		gui.Contexts.Tags.Context,
+		gui.Contexts.BranchCommits.Context,
+		gui.Contexts.CommitFiles.Context,
+		gui.Contexts.ReflogCommits.Context,
+		gui.Contexts.Stash.Context,
+		gui.Contexts.Menu.Context,
+		gui.Contexts.Confirmation.Context,
+		gui.Contexts.Credentials.Context,
+		gui.Contexts.CommitMessage.Context,
+		gui.Contexts.Normal.Context,
+		gui.Contexts.Staging.Context,
+		gui.Contexts.Merging.Context,
+		gui.Contexts.PatchBuilding.Context,
+		gui.Contexts.SubCommits.Context,
+	}
+}
+
 type Context interface {
 	HandleFocus() error
 	HandleFocusLost() error
 	HandleRender() error
-	GetKind() ContextKind
+	GetKind() int
 	GetViewName() string
 	GetWindowName() string
 	SetWindowName(string)
-	GetKey() ContextKey
+	GetKey() string
 	SetParentContext(Context)

 	// we return a bool here to tell us whether or not the returned value just wraps a nil
@@ -32,22 +134,261 @@ type Context interface {
 	GetOptionsMap() map[string]string
 }

-func (gui *Gui) popupViewNames() []string {
-	result := []string{}
-	for _, context := range gui.allContexts() {
-		if context.GetKind() == PERSISTENT_POPUP || context.GetKind() == TEMPORARY_POPUP {
-			result = append(result, context.GetViewName())
-		}
-	}
-
-	return result
+type BasicContext struct {
+	OnFocus         func() error
+	OnFocusLost     func() error
+	OnRender        func() error
+	OnGetOptionsMap func() map[string]string
+	Kind            int
+	Key             string
+	ViewName        string
 }

-func (gui *Gui) currentContextKeyIgnoringPopups() ContextKey {
-	gui.State.ContextManager.RLock()
-	defer gui.State.ContextManager.RUnlock()
+func (c BasicContext) GetOptionsMap() map[string]string {
+	if c.OnGetOptionsMap != nil {
+		return c.OnGetOptionsMap()
+	}
+	return nil
+}

-	stack := gui.State.ContextManager.ContextStack
+func (c BasicContext) SetWindowName(windowName string) {
+	panic("can't set window name on basic context")
+}
+
+func (c BasicContext) GetWindowName() string {
+	// TODO: fix this up
+	return c.GetViewName()
+}
+
+func (c BasicContext) SetParentContext(Context) {
+	panic("can't set parent context on basic context")
+}
+
+func (c BasicContext) GetParentContext() (Context, bool) {
+	return nil, false
+}
+
+func (c BasicContext) HandleRender() error {
+	if c.OnRender != nil {
+		return c.OnRender()
+	}
+	return nil
+}
+
+func (c BasicContext) GetViewName() string {
+	return c.ViewName
+}
+
+func (c BasicContext) HandleFocus() error {
+	return c.OnFocus()
+}
+
+func (c BasicContext) HandleFocusLost() error {
+	if c.OnFocusLost != nil {
+		return c.OnFocusLost()
+	}
+	return nil
+}
+
+func (c BasicContext) GetKind() int {
+	return c.Kind
+}
+
+func (c BasicContext) GetKey() string {
+	return c.Key
+}
+
+func (gui *Gui) contextTree() ContextTree {
+	return ContextTree{
+		Status: SimpleContextNode{
+			Context: BasicContext{
+				OnFocus:  gui.handleStatusSelect,
+				Kind:     SIDE_CONTEXT,
+				ViewName: "status",
+				Key:      STATUS_CONTEXT_KEY,
+			},
+		},
+		Files: SimpleContextNode{
+			Context: gui.filesListContext(),
+		},
+		Submodules: SimpleContextNode{
+			Context: gui.submodulesListContext(),
+		},
+		Menu: SimpleContextNode{
+			Context: gui.menuListContext(),
+		},
+		Remotes: RemotesContextNode{
+			Context: gui.remotesListContext(),
+			Branches: SimpleContextNode{
+				Context: gui.remoteBranchesListContext(),
+			},
+		},
+		BranchCommits: SimpleContextNode{
+			Context: gui.branchCommitsListContext(),
+		},
+		CommitFiles: SimpleContextNode{
+			Context: gui.commitFilesListContext(),
+		},
+		ReflogCommits: SimpleContextNode{
+			Context: gui.reflogCommitsListContext(),
+		},
+		SubCommits: SimpleContextNode{
+			Context: gui.subCommitsListContext(),
+		},
+		Branches: SimpleContextNode{
+			Context: gui.branchesListContext(),
+		},
+		Tags: SimpleContextNode{
+			Context: gui.tagsListContext(),
+		},
+		Stash: SimpleContextNode{
+			Context: gui.stashListContext(),
+		},
+		Normal: SimpleContextNode{
+			Context: BasicContext{
+				OnFocus: func() error {
+					return nil // TODO: should we do something here? We should allow for scrolling the panel
+				},
+				Kind:     MAIN_CONTEXT,
+				ViewName: "main",
+				Key:      MAIN_NORMAL_CONTEXT_KEY,
+			},
+		},
+		Staging: SimpleContextNode{
+			Context: BasicContext{
+				OnFocus: func() error {
+					return nil
+					// TODO: centralise the code here
+					// return gui.refreshStagingPanel(false, -1)
+				},
+				Kind:     MAIN_CONTEXT,
+				ViewName: "main",
+				Key:      MAIN_STAGING_CONTEXT_KEY,
+			},
+		},
+		PatchBuilding: SimpleContextNode{
+			Context: BasicContext{
+				OnFocus: func() error {
+					return nil
+					// TODO: centralise the code here
+					// return gui.refreshPatchBuildingPanel(-1)
+				},
+				Kind:     MAIN_CONTEXT,
+				ViewName: "main",
+				Key:      MAIN_PATCH_BUILDING_CONTEXT_KEY,
+			},
+		},
+		Merging: SimpleContextNode{
+			Context: BasicContext{
+				OnFocus: func() error {
+					return gui.refreshMergePanel()
+				},
+				Kind:            MAIN_CONTEXT,
+				ViewName:        "main",
+				Key:             MAIN_MERGING_CONTEXT_KEY,
+				OnGetOptionsMap: gui.getMergingOptions,
+			},
+		},
+		Credentials: SimpleContextNode{
+			Context: BasicContext{
+				OnFocus:  func() error { return gui.handleCredentialsViewFocused() },
+				Kind:     PERSISTENT_POPUP,
+				ViewName: "credentials",
+				Key:      CREDENTIALS_CONTEXT_KEY,
+			},
+		},
+		Confirmation: SimpleContextNode{
+			Context: BasicContext{
+				OnFocus:  func() error { return nil },
+				Kind:     TEMPORARY_POPUP,
+				ViewName: "confirmation",
+				Key:      CONFIRMATION_CONTEXT_KEY,
+			},
+		},
+		CommitMessage: SimpleContextNode{
+			Context: BasicContext{
+				OnFocus:  func() error { return gui.handleCommitMessageFocused() },
+				Kind:     PERSISTENT_POPUP,
+				ViewName: "commitMessage",
+				Key:      COMMIT_MESSAGE_CONTEXT_KEY,
+			},
+		},
+		Search: SimpleContextNode{
+			Context: BasicContext{
+				OnFocus:  func() error { return nil },
+				Kind:     PERSISTENT_POPUP,
+				ViewName: "search",
+				Key:      SEARCH_CONTEXT_KEY,
+			},
+		},
+	}
+}
+
+func (gui *Gui) initialViewContextMap() map[string]Context {
+	return map[string]Context{
+		"status":        gui.Contexts.Status.Context,
+		"files":         gui.Contexts.Files.Context,
+		"branches":      gui.Contexts.Branches.Context,
+		"commits":       gui.Contexts.BranchCommits.Context,
+		"commitFiles":   gui.Contexts.CommitFiles.Context,
+		"stash":         gui.Contexts.Stash.Context,
+		"menu":          gui.Contexts.Menu.Context,
+		"confirmation":  gui.Contexts.Confirmation.Context,
+		"credentials":   gui.Contexts.Credentials.Context,
+		"commitMessage": gui.Contexts.CommitMessage.Context,
+		"main":          gui.Contexts.Normal.Context,
+		"secondary":     gui.Contexts.Normal.Context,
+	}
+}
+
+func (gui *Gui) viewTabContextMap() map[string][]tabContext {
+	return map[string][]tabContext{
+		"branches": {
+			{
+				tab:      "Local Branches",
+				contexts: []Context{gui.Contexts.Branches.Context},
+			},
+			{
+				tab: "Remotes",
+				contexts: []Context{
+					gui.Contexts.Remotes.Context,
+					gui.Contexts.Remotes.Branches.Context,
+				},
+			},
+			{
+				tab:      "Tags",
+				contexts: []Context{gui.Contexts.Tags.Context},
+			},
+		},
+		"commits": {
+			{
+				tab:      "Commits",
+				contexts: []Context{gui.Contexts.BranchCommits.Context},
+			},
+			{
+				tab: "Reflog",
+				contexts: []Context{
+					gui.Contexts.ReflogCommits.Context,
+				},
+			},
+		},
+		"files": {
+			{
+				tab:      "Files",
+				contexts: []Context{gui.Contexts.Files.Context},
+			},
+			{
+				tab: "Submodules",
+				contexts: []Context{
+					gui.Contexts.Submodules.Context,
+				},
+			},
+		},
+	}
+}
+
+func (gui *Gui) currentContextKeyIgnoringPopups() string {
+	stack := gui.State.ContextStack

 	for i := range stack {
 		reversedIndex := len(stack) - 1 - i
@@ -61,18 +402,22 @@ func (gui *Gui) currentContextKeyIgnoringPopups() ContextKey {
 	return ""
 }

-// use replaceContext when you don't want to return to the original context upon
-// hitting escape: you want to go that context's parent instead.
-func (gui *Gui) replaceContext(c Context) error {
+func (gui *Gui) switchContext(c Context) error {
 	gui.g.Update(func(*gocui.Gui) error {
-		gui.State.ContextManager.Lock()
-		defer gui.State.ContextManager.Unlock()
-
-		if len(gui.State.ContextManager.ContextStack) == 0 {
-			gui.State.ContextManager.ContextStack = []Context{c}
+		// push onto stack
+		// if we are switching to a side context, remove all other contexts in the stack
+		if c.GetKind() == SIDE_CONTEXT {
+			for _, stackContext := range gui.State.ContextStack {
+				if stackContext.GetKey() != c.GetKey() {
+					if err := gui.deactivateContext(stackContext); err != nil {
+						return err
+					}
+				}
+			}
+			gui.State.ContextStack = []Context{c}
 		} else {
-			// replace the last item with the given item
-			gui.State.ContextManager.ContextStack = append(gui.State.ContextManager.ContextStack[0:len(gui.State.ContextManager.ContextStack)-1], c)
+			// TODO: think about other exceptional cases
+			gui.State.ContextStack = append(gui.State.ContextStack, c)
 		}

 		return gui.activateContext(c)
@@ -81,96 +426,43 @@ func (gui *Gui) replaceContext(c Context) error {
 	return nil
 }

-func (gui *Gui) pushContext(c Context) error {
-	gui.g.Update(func(*gocui.Gui) error {
-		return gui.pushContextDirect(c)
-	})
-
-	return nil
-}
-
-func (gui *Gui) pushContextDirect(c Context) error {
-	gui.State.ContextManager.Lock()
-
-	// push onto stack
-	// if we are switching to a side context, remove all other contexts in the stack
-	if c.GetKind() == SIDE_CONTEXT {
-		for _, stackContext := range gui.State.ContextManager.ContextStack {
-			if stackContext.GetKey() != c.GetKey() {
-				if err := gui.deactivateContext(stackContext); err != nil {
-					gui.State.ContextManager.Unlock()
-					return err
-				}
-			}
-		}
-		gui.State.ContextManager.ContextStack = []Context{c}
-	} else if len(gui.State.ContextManager.ContextStack) == 0 || gui.currentContextWithoutLock().GetKey() != c.GetKey() {
-		// Do not append if the one at the end is the same context (e.g. opening a menu from a menu)
-		// In that case we'll just close the menu entirely when the user hits escape.
-
-		// TODO: think about other exceptional cases
-		gui.State.ContextManager.ContextStack = append(gui.State.ContextManager.ContextStack, c)
-	}
-
-	gui.State.ContextManager.Unlock()
-
-	return gui.activateContext(c)
-}
-
-// asynchronous code idea: functions return an error via a channel, when done
-
-// pushContextWithView is to be used when you don't know which context you
+// switchContextToView is to be used when you don't know which context you
 // want to switch to: you only know the view that you want to switch to. It will
 // look up the context currently active for that view and switch to that context
-func (gui *Gui) pushContextWithView(viewName string) error {
-	return gui.pushContext(gui.State.ViewContextMap[viewName])
+func (gui *Gui) switchContextToView(viewName string) error {
+	return gui.switchContext(gui.State.ViewContextMap[viewName])
 }

 func (gui *Gui) returnFromContext() error {
 	gui.g.Update(func(*gocui.Gui) error {
-		return gui.returnFromContextSync()
+		// TODO: add mutexes
+
+		if len(gui.State.ContextStack) == 1 {
+			// cannot escape from bottommost context
+			return nil
+		}
+
+		n := len(gui.State.ContextStack) - 1
+
+		currentContext := gui.State.ContextStack[n]
+		newContext := gui.State.ContextStack[n-1]
+
+		gui.State.ContextStack = gui.State.ContextStack[:n]
+
+		if err := gui.deactivateContext(currentContext); err != nil {
+			return err
+		}
+
+		return gui.activateContext(newContext)
 	})

 	return nil
 }

-func (gui *Gui) returnFromContextSync() error {
-	gui.State.ContextManager.Lock()
-
-	if len(gui.State.ContextManager.ContextStack) == 1 {
-		// cannot escape from bottommost context
-		gui.State.ContextManager.Unlock()
-		return nil
-	}
-
-	n := len(gui.State.ContextManager.ContextStack) - 1
-
-	currentContext := gui.State.ContextManager.ContextStack[n]
-	newContext := gui.State.ContextManager.ContextStack[n-1]
-
-	gui.State.ContextManager.ContextStack = gui.State.ContextManager.ContextStack[:n]
-
-	gui.State.ContextManager.Unlock()
-
-	if err := gui.deactivateContext(currentContext); err != nil {
-		return err
-	}
-
-	return gui.activateContext(newContext)
-}
-
 func (gui *Gui) deactivateContext(c Context) error {
-	view, _ := gui.g.View(c.GetViewName())
-
-	if view != nil && view.IsSearching() {
-		if err := gui.onSearchEscape(); err != nil {
-			return err
-		}
-	}
-
 	// if we are the kind of context that is sent to back upon deactivation, we should do that
-	if view != nil && c.GetKind() == TEMPORARY_POPUP || c.GetKind() == PERSISTENT_POPUP || c.GetKey() == COMMIT_FILES_CONTEXT_KEY {
-		view.Visible = false
+	if c.GetKind() == TEMPORARY_POPUP || c.GetKind() == PERSISTENT_POPUP {
+		_, _ = gui.g.SetViewOnBottom(c.GetViewName())
 	}

 	if err := c.HandleFocusLost(); err != nil {
@@ -189,7 +481,7 @@ func (gui *Gui) postRefreshUpdate(c Context) error {
 		return nil
 	}

-	if ContextKey(v.Context) != c.GetKey() {
+	if v.Context != c.GetKey() {
 		return nil
 	}

@@ -209,27 +501,32 @@ func (gui *Gui) postRefreshUpdate(c Context) error {
 func (gui *Gui) activateContext(c Context) error {
 	viewName := c.GetViewName()
 	v, err := gui.g.View(viewName)
+	// if view no longer exists, pop again
 	if err != nil {
-		return err
+		return gui.returnFromContext()
 	}
-	originalViewContextKey := ContextKey(v.Context)
+	originalViewContextKey := v.Context

 	// ensure that any other window for which this view was active is now set to the default for that window.
-	gui.setViewAsActiveForWindow(v)
+	gui.setViewAsActiveForWindow(viewName)

 	if viewName == "main" {
 		gui.changeMainViewsContext(c.GetKey())
 	} else {
-		gui.changeMainViewsContext(MAIN_NORMAL_CONTEXT_KEY)
+		gui.changeMainViewsContext("normal")
 	}

 	gui.setViewTabForContext(c)

 	if _, err := gui.g.SetCurrentView(viewName); err != nil {
-		return err
+		// if view no longer exists, pop again
+		return gui.returnFromContext()
 	}

-	v.Visible = true
+	if _, err := gui.g.SetViewOnTop(viewName); err != nil {
+		// if view no longer exists, pop again
+		return gui.returnFromContext()
+	}

 	// if the new context's view was previously displaying another context, render the new context
 	if originalViewContextKey != c.GetKey() {
@@ -238,7 +535,7 @@ func (gui *Gui) activateContext(c Context) error {
 		}
 	}

-	v.Context = string(c.GetKey())
+	v.Context = c.GetKey()

 	gui.g.Cursor = v.Editable

@@ -259,50 +556,28 @@ func (gui *Gui) activateContext(c Context) error {
 	return nil
 }

-// // currently unused
-// func (gui *Gui) renderContextStack() string {
-// 	result := ""
-// 	for _, context := range gui.State.ContextManager.ContextStack {
-// 		result += string(context.GetKey()) + "\n"
-// 	}
-// 	return result
-// }
-
-func (gui *Gui) currentContext() Context {
-	gui.State.ContextManager.RLock()
-	defer gui.State.ContextManager.RUnlock()
-
-	return gui.currentContextWithoutLock()
+func (gui *Gui) renderContextStack() string {
+	result := ""
+	for _, context := range gui.State.ContextStack {
+		result += context.GetKey() + "\n"
+	}
+	return result
 }

-func (gui *Gui) currentContextWithoutLock() Context {
-	if len(gui.State.ContextManager.ContextStack) == 0 {
+func (gui *Gui) currentContext() Context {
+	if len(gui.State.ContextStack) == 0 {
 		return gui.defaultSideContext()
 	}

-	return gui.State.ContextManager.ContextStack[len(gui.State.ContextManager.ContextStack)-1]
+	return gui.State.ContextStack[len(gui.State.ContextStack)-1]
 }

-// the status panel is not yet a list context (and may never be), so this method is not
-// quite the same as currentSideContext()
-func (gui *Gui) currentSideListContext() IListContext {
-	context := gui.currentSideContext()
-	listContext, ok := context.(IListContext)
-	if !ok {
-		return nil
-	}
-	return listContext
-}
-
-func (gui *Gui) currentSideContext() Context {
-	gui.State.ContextManager.RLock()
-	defer gui.State.ContextManager.RUnlock()
-
-	stack := gui.State.ContextManager.ContextStack
+func (gui *Gui) currentSideContext() *ListContext {
+	stack := gui.State.ContextStack

 	// on startup the stack can be empty so we'll return an empty string in that case
 	if len(stack) == 0 {
-		return gui.defaultSideContext()
+		return nil
 	}

 	// find the first context in the stack with the type of SIDE_CONTEXT
@@ -310,45 +585,22 @@ func (gui *Gui) currentSideContext() Context {
 		context := stack[len(stack)-1-i]

 		if context.GetKind() == SIDE_CONTEXT {
-			return context
+			// not all side contexts are list contexts (e.g. the status panel)
+			listContext, ok := context.(*ListContext)
+			if !ok {
+				return nil
+			}
+			return listContext
 		}
 	}

-	return gui.defaultSideContext()
-}
-
-// static as opposed to popup
-func (gui *Gui) currentStaticContext() Context {
-	gui.State.ContextManager.RLock()
-	defer gui.State.ContextManager.RUnlock()
-
-	stack := gui.State.ContextManager.ContextStack
-
-	if len(stack) == 0 {
-		return gui.defaultSideContext()
-	}
-
-	// find the first context in the stack without a popup type
-	for i := range stack {
-		context := stack[len(stack)-1-i]
-
-		if context.GetKind() != TEMPORARY_POPUP && context.GetKind() != PERSISTENT_POPUP {
-			return context
-		}
-	}
-
-	return gui.defaultSideContext()
+	return nil
 }

 func (gui *Gui) defaultSideContext() Context {
-	if gui.State.Modes.Filtering.Active() {
-		return gui.State.Contexts.BranchCommits
-	} else {
-		return gui.State.Contexts.Files
-	}
+	return gui.Contexts.Files.Context
 }

-// remove the need to do this: always use a mapping
 func (gui *Gui) setInitialViewContexts() {
 	// arguably we should only have our ViewContextMap and we should do away with
 	// contexts on views, or vice versa
@@ -359,7 +611,7 @@ func (gui *Gui) setInitialViewContexts() {
 			continue
 		}

-		view.Context = string(context.GetKey())
+		view.Context = context.GetKey()
 	}
 }

@@ -389,21 +641,18 @@ func (gui *Gui) onViewFocusChange() error {

 	currentView := gui.g.CurrentView()
 	for _, view := range gui.g.Views() {
-		view.Highlight = view.Name() != "main" && view.Name() != "extras" && view == currentView
+		view.Highlight = view.Name() != "main" && view == currentView
 	}
 	return nil
 }

-func (gui *Gui) onViewFocusLost(oldView *gocui.View, newView *gocui.View) error {
-	if oldView == nil {
+func (gui *Gui) onViewFocusLost(v *gocui.View, newView *gocui.View) error {
+	if v == nil {
 		return nil
 	}

-	_ = oldView.SetOriginX(0)
-
-	if oldView == gui.Views.CommitFiles && newView != gui.Views.Main && newView != gui.Views.Secondary && newView != gui.Views.Search {
-		gui.resetWindowForView(gui.Views.CommitFiles)
-		if err := gui.deactivateContext(gui.State.Contexts.CommitFiles); err != nil {
+	if v.IsSearching() && newView.Name() != "search" {
+		if err := gui.onSearchEscape(); err != nil {
 			return err
 		}
 	}
@@ -415,15 +664,15 @@ func (gui *Gui) onViewFocusLost(oldView *gocui.View, newView *gocui.View) error
 // which currently just means a context that affects both the main and secondary views
 // other views can have their context changed directly but this function helps
 // keep the main and secondary views in sync
-func (gui *Gui) changeMainViewsContext(contextKey ContextKey) {
+func (gui *Gui) changeMainViewsContext(contextKey string) {
 	if gui.State.MainContext == contextKey {
 		return
 	}

 	switch contextKey {
 	case MAIN_NORMAL_CONTEXT_KEY, MAIN_PATCH_BUILDING_CONTEXT_KEY, MAIN_STAGING_CONTEXT_KEY, MAIN_MERGING_CONTEXT_KEY:
-		gui.Views.Main.Context = string(contextKey)
-		gui.Views.Secondary.Context = string(contextKey)
+		gui.getMainView().Context = contextKey
+		gui.getSecondaryView().Context = contextKey
 	default:
 		panic(fmt.Sprintf("unknown context for main: %s", contextKey))
 	}
@@ -432,7 +681,7 @@ func (gui *Gui) changeMainViewsContext(contextKey ContextKey) {
 }

 func (gui *Gui) viewTabNames(viewName string) []string {
-	tabContexts := gui.State.ViewTabContextMap[viewName]
+	tabContexts := gui.ViewTabContextMap[viewName]

 	if len(tabContexts) == 0 {
 		return nil
@@ -448,7 +697,7 @@ func (gui *Gui) viewTabNames(viewName string) []string {

 func (gui *Gui) setViewTabForContext(c Context) {
 	// search for the context in our map and if we find it, set the tab for the corresponding view
-	tabContexts, ok := gui.State.ViewTabContextMap[c.GetViewName()]
+	tabContexts, ok := gui.ViewTabContextMap[c.GetViewName()]
 	if !ok {
 		return
 	}
@@ -474,7 +723,7 @@ type tabContext struct {
 	contexts []Context
 }

-func (gui *Gui) mustContextForContextKey(contextKey ContextKey) Context {
+func (gui *Gui) mustContextForContextKey(contextKey string) Context {
 	context, ok := gui.contextForContextKey(contextKey)

 	if !ok {
@@ -484,7 +733,7 @@ func (gui *Gui) mustContextForContextKey(contextKey ContextKey) Context {
 	return context
 }

-func (gui *Gui) contextForContextKey(contextKey ContextKey) (Context, bool) {
+func (gui *Gui) contextForContextKey(contextKey string) (Context, bool) {
 	for _, context := range gui.allContexts() {
 		if context.GetKey() == contextKey {
 			return context, true
@@ -494,15 +743,31 @@ func (gui *Gui) contextForContextKey(contextKey ContextKey) (Context, bool) {
 	return nil, false
 }

-func (gui *Gui) rerenderView(view *gocui.View) error {
-	contextKey := ContextKey(view.Context)
+func (gui *Gui) rerenderView(viewName string) error {
+	v, err := gui.g.View(viewName)
+	if err != nil {
+		return nil
+	}
+
+	contextKey := v.Context
 	context := gui.mustContextForContextKey(contextKey)

 	return context.HandleRender()
 }

+func (gui *Gui) getCurrentSideView() *gocui.View {
+	currentSideContext := gui.currentSideContext()
+	if currentSideContext == nil {
+		return nil
+	}
+
+	view, _ := gui.g.View(currentSideContext.GetViewName())
+
+	return view
+}
+
 func (gui *Gui) getSideContextSelectedItemId() string {
-	currentSideContext := gui.currentSideListContext()
+	currentSideContext := gui.currentSideContext()
 	if currentSideContext == nil {
 		return ""
 	}
@@ -515,24 +780,3 @@ func (gui *Gui) getSideContextSelectedItemId() string {

 	return ""
 }
-
-// currently unused
-// func (gui *Gui) getCurrentSideView() *gocui.View {
-// 	currentSideContext := gui.currentSideContext()
-// 	if currentSideContext == nil {
-// 		return nil
-// 	}
-
-// 	view, _ := gui.g.View(currentSideContext.GetViewName())
-
-// 	return view
-// }
-
-// currently unused
-// func (gui *Gui) renderContextStack() string {
-// 	result := ""
-// 	for _, context := range gui.State.ContextManager.ContextStack {
-// 		result += context.GetViewName() + "\n"
-// 	}
-// 	return result
-// }
@@ -1,266 +0,0 @@
-package gui
-
-type ContextKey string
-
-const (
-	STATUS_CONTEXT_KEY              ContextKey = "status"
-	FILES_CONTEXT_KEY               ContextKey = "files"
-	LOCAL_BRANCHES_CONTEXT_KEY      ContextKey = "localBranches"
-	REMOTES_CONTEXT_KEY             ContextKey = "remotes"
-	REMOTE_BRANCHES_CONTEXT_KEY     ContextKey = "remoteBranches"
-	TAGS_CONTEXT_KEY                ContextKey = "tags"
-	BRANCH_COMMITS_CONTEXT_KEY      ContextKey = "commits"
-	REFLOG_COMMITS_CONTEXT_KEY      ContextKey = "reflogCommits"
-	SUB_COMMITS_CONTEXT_KEY         ContextKey = "subCommits"
-	COMMIT_FILES_CONTEXT_KEY        ContextKey = "commitFiles"
-	STASH_CONTEXT_KEY               ContextKey = "stash"
-	MAIN_NORMAL_CONTEXT_KEY         ContextKey = "normal"
-	MAIN_MERGING_CONTEXT_KEY        ContextKey = "merging"
-	MAIN_PATCH_BUILDING_CONTEXT_KEY ContextKey = "patchBuilding"
-	MAIN_STAGING_CONTEXT_KEY        ContextKey = "staging"
-	MENU_CONTEXT_KEY                ContextKey = "menu"
-	CREDENTIALS_CONTEXT_KEY         ContextKey = "credentials"
-	CONFIRMATION_CONTEXT_KEY        ContextKey = "confirmation"
-	SEARCH_CONTEXT_KEY              ContextKey = "search"
-	COMMIT_MESSAGE_CONTEXT_KEY      ContextKey = "commitMessage"
-	SUBMODULES_CONTEXT_KEY          ContextKey = "submodules"
-	SUGGESTIONS_CONTEXT_KEY         ContextKey = "suggestions"
-	COMMAND_LOG_CONTEXT_KEY         ContextKey = "cmdLog"
-)
-
-var allContextKeys = []ContextKey{
-	STATUS_CONTEXT_KEY,
-	FILES_CONTEXT_KEY,
-	LOCAL_BRANCHES_CONTEXT_KEY,
-	REMOTES_CONTEXT_KEY,
-	REMOTE_BRANCHES_CONTEXT_KEY,
-	TAGS_CONTEXT_KEY,
-	BRANCH_COMMITS_CONTEXT_KEY,
-	REFLOG_COMMITS_CONTEXT_KEY,
-	SUB_COMMITS_CONTEXT_KEY,
-	COMMIT_FILES_CONTEXT_KEY,
-	STASH_CONTEXT_KEY,
-	MAIN_NORMAL_CONTEXT_KEY,
-	MAIN_MERGING_CONTEXT_KEY,
-	MAIN_PATCH_BUILDING_CONTEXT_KEY,
-	MAIN_STAGING_CONTEXT_KEY,
-	MENU_CONTEXT_KEY,
-	CREDENTIALS_CONTEXT_KEY,
-	CONFIRMATION_CONTEXT_KEY,
-	SEARCH_CONTEXT_KEY,
-	COMMIT_MESSAGE_CONTEXT_KEY,
-	SUBMODULES_CONTEXT_KEY,
-	SUGGESTIONS_CONTEXT_KEY,
-	COMMAND_LOG_CONTEXT_KEY,
-}
-
-type ContextTree struct {
-	Status         Context
-	Files          IListContext
-	Submodules     IListContext
-	Menu           IListContext
-	Branches       IListContext
-	Remotes        IListContext
-	RemoteBranches IListContext
-	Tags           IListContext
-	BranchCommits  IListContext
-	CommitFiles    IListContext
-	ReflogCommits  IListContext
-	SubCommits     IListContext
-	Stash          IListContext
-	Suggestions    IListContext
-	Normal         Context
-	Staging        Context
-	PatchBuilding  Context
-	Merging        Context
-	Credentials    Context
-	Confirmation   Context
-	CommitMessage  Context
-	Search         Context
-	CommandLog     Context
-}
-
-func (gui *Gui) allContexts() []Context {
-	return []Context{
-		gui.State.Contexts.Status,
-		gui.State.Contexts.Files,
-		gui.State.Contexts.Submodules,
-		gui.State.Contexts.Branches,
-		gui.State.Contexts.Remotes,
-		gui.State.Contexts.RemoteBranches,
-		gui.State.Contexts.Tags,
-		gui.State.Contexts.BranchCommits,
-		gui.State.Contexts.CommitFiles,
-		gui.State.Contexts.ReflogCommits,
-		gui.State.Contexts.Stash,
-		gui.State.Contexts.Menu,
-		gui.State.Contexts.Confirmation,
-		gui.State.Contexts.Credentials,
-		gui.State.Contexts.CommitMessage,
-		gui.State.Contexts.Normal,
-		gui.State.Contexts.Staging,
-		gui.State.Contexts.Merging,
-		gui.State.Contexts.PatchBuilding,
-		gui.State.Contexts.SubCommits,
-		gui.State.Contexts.Suggestions,
-		gui.State.Contexts.CommandLog,
-	}
-}
-
-func (gui *Gui) contextTree() ContextTree {
-	return ContextTree{
-		Status: &BasicContext{
-			OnFocus:  gui.handleStatusSelect,
-			Kind:     SIDE_CONTEXT,
-			ViewName: "status",
-			Key:      STATUS_CONTEXT_KEY,
-		},
-		Files:          gui.filesListContext(),
-		Submodules:     gui.submodulesListContext(),
-		Menu:           gui.menuListContext(),
-		Remotes:        gui.remotesListContext(),
-		RemoteBranches: gui.remoteBranchesListContext(),
-		BranchCommits:  gui.branchCommitsListContext(),
-		CommitFiles:    gui.commitFilesListContext(),
-		ReflogCommits:  gui.reflogCommitsListContext(),
-		SubCommits:     gui.subCommitsListContext(),
-		Branches:       gui.branchesListContext(),
-		Tags:           gui.tagsListContext(),
-		Stash:          gui.stashListContext(),
-		Normal: &BasicContext{
-			OnFocus: func() error {
-				return nil // TODO: should we do something here? We should allow for scrolling the panel
-			},
-			Kind:     MAIN_CONTEXT,
-			ViewName: "main",
-			Key:      MAIN_NORMAL_CONTEXT_KEY,
-		},
-		Staging: &BasicContext{
-			OnFocus: func() error {
-				return nil
-				// TODO: centralise the code here
-				// return gui.refreshStagingPanel(false, -1)
-			},
-			Kind:     MAIN_CONTEXT,
-			ViewName: "main",
-			Key:      MAIN_STAGING_CONTEXT_KEY,
-		},
-		PatchBuilding: &BasicContext{
-			OnFocus: func() error {
-				return nil
-				// TODO: centralise the code here
-				// return gui.refreshPatchBuildingPanel(-1)
-			},
-			Kind:     MAIN_CONTEXT,
-			ViewName: "main",
-			Key:      MAIN_PATCH_BUILDING_CONTEXT_KEY,
-		},
-		Merging: &BasicContext{
-			OnFocus:         gui.refreshMergePanelWithLock,
-			Kind:            MAIN_CONTEXT,
-			ViewName:        "main",
-			Key:             MAIN_MERGING_CONTEXT_KEY,
-			OnGetOptionsMap: gui.getMergingOptions,
-		},
-		Credentials: &BasicContext{
-			OnFocus:  gui.handleCredentialsViewFocused,
-			Kind:     PERSISTENT_POPUP,
-			ViewName: "credentials",
-			Key:      CREDENTIALS_CONTEXT_KEY,
-		},
-		Confirmation: &BasicContext{
-			OnFocus:  func() error { return nil },
-			Kind:     TEMPORARY_POPUP,
-			ViewName: "confirmation",
-			Key:      CONFIRMATION_CONTEXT_KEY,
-		},
-		Suggestions: gui.suggestionsListContext(),
-		CommitMessage: &BasicContext{
-			OnFocus:  gui.handleCommitMessageFocused,
-			Kind:     PERSISTENT_POPUP,
-			ViewName: "commitMessage",
-			Key:      COMMIT_MESSAGE_CONTEXT_KEY,
-		},
-		Search: &BasicContext{
-			OnFocus:  func() error { return nil },
-			Kind:     PERSISTENT_POPUP,
-			ViewName: "search",
-			Key:      SEARCH_CONTEXT_KEY,
-		},
-		CommandLog: &BasicContext{
-			OnFocus:         func() error { return nil },
-			Kind:            EXTRAS_CONTEXT,
-			ViewName:        "extras",
-			Key:             COMMAND_LOG_CONTEXT_KEY,
-			OnGetOptionsMap: gui.getMergingOptions,
-			OnFocusLost: func() error {
-				gui.Views.Extras.Autoscroll = true
-				return nil
-			},
-		},
-	}
-}
-
-func (tree ContextTree) initialViewContextMap() map[string]Context {
-	return map[string]Context{
-		"status":        tree.Status,
-		"files":         tree.Files,
-		"branches":      tree.Branches,
-		"commits":       tree.BranchCommits,
-		"commitFiles":   tree.CommitFiles,
-		"stash":         tree.Stash,
-		"menu":          tree.Menu,
-		"confirmation":  tree.Confirmation,
-		"credentials":   tree.Credentials,
-		"commitMessage": tree.CommitMessage,
-		"main":          tree.Normal,
-		"secondary":     tree.Normal,
-		"extras":        tree.CommandLog,
-	}
-}
-
-func (tree ContextTree) initialViewTabContextMap() map[string][]tabContext {
-	return map[string][]tabContext{
-		"branches": {
-			{
-				tab:      "Local Branches",
-				contexts: []Context{tree.Branches},
-			},
-			{
-				tab: "Remotes",
-				contexts: []Context{
-					tree.Remotes,
-					tree.RemoteBranches,
-				},
-			},
-			{
-				tab:      "Tags",
-				contexts: []Context{tree.Tags},
-			},
-		},
-		"commits": {
-			{
-				tab:      "Commits",
-				contexts: []Context{tree.BranchCommits},
-			},
-			{
-				tab: "Reflog",
-				contexts: []Context{
-					tree.ReflogCommits,
-				},
-			},
-		},
-		"files": {
-			{
-				tab:      "Files",
-				contexts: []Context{tree.Files},
-			},
-			{
-				tab: "Submodules",
-				contexts: []Context{
-					tree.Submodules,
-				},
-			},
-		},
-	}
-}
@@ -13,20 +13,19 @@ type credentials chan string
 func (gui *Gui) promptUserForCredential(passOrUname string) string {
 	gui.credentials = make(chan string)
 	gui.g.Update(func(g *gocui.Gui) error {
-		credentialsView := gui.Views.Credentials
-		switch passOrUname {
-		case "username":
+		credentialsView, _ := g.View("credentials")
+		if passOrUname == "username" {
 			credentialsView.Title = gui.Tr.CredentialsUsername
 			credentialsView.Mask = 0
-		case "password":
+		} else if passOrUname == "password" {
 			credentialsView.Title = gui.Tr.CredentialsPassword
 			credentialsView.Mask = '*'
-		default:
+		} else {
 			credentialsView.Title = gui.Tr.CredentialsPassphrase
 			credentialsView.Mask = '*'
 		}

-		if err := gui.pushContext(gui.State.Contexts.Credentials); err != nil {
+		if err := gui.switchContext(gui.Contexts.Credentials.Context); err != nil {
 			return err
 		}

@@ -39,19 +38,18 @@ func (gui *Gui) promptUserForCredential(passOrUname string) string {
 	return userInput + "\n"
 }

-func (gui *Gui) handleSubmitCredential() error {
-	credentialsView := gui.Views.Credentials
-	message := strings.TrimSpace(credentialsView.TextArea.GetContent())
+func (gui *Gui) handleSubmitCredential(g *gocui.Gui, v *gocui.View) error {
+	message := gui.trimmedContent(v)
 	gui.credentials <- message
-	credentialsView.ClearTextArea()
+	gui.clearEditorView(v)
 	if err := gui.returnFromContext(); err != nil {
 		return err
 	}

-	return gui.refreshSidePanels(refreshOptions{mode: ASYNC})
+	return gui.refreshSidePanels(refreshOptions{})
 }

-func (gui *Gui) handleCloseCredentialsView() error {
+func (gui *Gui) handleCloseCredentialsView(g *gocui.Gui, v *gocui.View) error {
 	gui.credentials <- ""
 	return gui.returnFromContext()
 }
@@ -67,7 +65,7 @@ func (gui *Gui) handleCredentialsViewFocused() error {
 		},
 	)

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

@@ -78,9 +76,8 @@ func (gui *Gui) handleCredentialsPopup(cmdErr error) {
 		if strings.Contains(errMessage, "Invalid username, password or passphrase") {
 			errMessage = gui.Tr.PassUnameWrong
 		}
-		_ = gui.returnFromContext()
 		// we are not logging this error because it may contain a password or a passphrase
-		_ = gui.createErrorPanel(errMessage)
+		gui.createErrorPanel(errMessage)
 	} else {
 		_ = gui.closeConfirmationPrompt(false)
 	}
--- a/Show More
+++ b/Show More