Help & Support

When you perform a history manipulation that results in a conflict, Retcon will pause, and prepare for conflict resolution.

You can resolve conflicts in multiple ways:

• Resolve the conflict in an editor or merge tool.

  Resolve the conflict as with a conventional Git client, by opening the conflicting files in either a code editor, or a merge tool.

  When done, mark the conflict as resolved by staging the files, then choose Apply Resolution to continue.

• Dismiss the conflict by making additional changes.

  It is still possible to manipulate history while Retcon is paused. When you make a change while paused, Retcon dismisses the current conflict, and evaluates the new history you've created. If that new history does not create a conflict, Retcon unpauses.

  For instance, if two commits that modify the same line of code are swapped, a conflict will occur. In that case, reorganize the commits to be in their original order again.

• Undo the manipulations.

  If the conflict is unexpected, you can undo the history manipulation by choosing Edit > Undo (⌘Z). This will revert to the previous version of the history, and unpause Retcon.

To edit the changes of any commit:

1. Select the commit, and choose Edit (⇧⌘E).

   Retcon rewinds to this commit, and pauses. The files in your repository now reflect the commit's state.

2. In your code editor, edit the files as desired.
3. Back in Retcon, stage all the files you modified, and confirm the edit by choosing Apply Changes (⌘⏎).

To remove select changes from a commit, and move them to a new commit:

1. Select the commit to split, and choose Edit (⇧⌘E).

2. Unstage the file changes you wish to move, then choose Apply Changes (⌘⏎).

   An empty commit is created and selected. The working directory contains the changes you unstaged.

3. Stage the changes to include in the new commit.

   You can choose to stage all changes, or leave some unstaged to create yet another split commit.

4. Enter a message for the new commit, then choose Create Commit (⌘⏎) to finalize it.

5. If you left some changes unstaged, repeat steps 3 through 5.

Almost any operation in Retcon can be reverted using Edit > Undo (⌘Z).

These operations cannot be reverted with undo:

• Switching branches. Instead, choose Branch > Go Back (⌘[), or use the Back/Forward toolbar buttons.
• Discarding changes in a file or folder
• Modifying a file in another app

These operations can be reverted with undo:

• Staging or unstaging files
• Reverting the stage
• Creating a commit
• Amending a commit
• Moving a commit
• Fixupping a commit
• Deleting a commit
• Editing a commit message
• Beginning/confirming/skipping a commit edit
• Confirming a conflict resolution
• Reverting a conflict resolution
• Rebasing a branch
• Merging a branch
• Creating or deleting a branch
• Aborting a rewrite
• Pushing a branch to a remote
• Pulling a branch from a remote
• Changing the history in another app
• Changing the stage in another app

As an alternative to HTTPS authentication, you can use SSH authentication to pull from and push to remotes. With SSH authentication, you don't use a username/password pair, and instead use a key.

To setup or troubleshoot SSH authentication, check all of the following:

• Add the remote with its SSH URL, not its HTTPS URL. Git decides how to authenticate based on the remote URL specified in your local repository.
  You can list a repository's remotes by running git remote -vv.
• Generate a SSH key, and store it in ~/.ssh/. Make sure both of its components are there: public and private.
  You typically only need a single key, that you can then use to authenticate with any number of servers. These keys are not Git-specific.
• Give your SSH agent access to your key. The private component of a key is usually encrypted with a passphrase of your choice. macOS's built-in agent reads this passphrase from the system keychain.
  To make sure the passphrase is stored in the keychain, run git fetch from your repository's folder. If necessary, you will be prompted for your passphrase, which will be stored in the keychain.
• Add the key to your Git host account. Log into your remote's host website, and add your public key to your account. This will instruct the host to recognize that key as a way to authenticate you.

More complex setups can be created by writing a config file, placed in the ~/.ssh/ folder. This is commonly used to assign different keys for use with different remotes, for instance to distinguish between a personal and a work identity.

For more detailed instructions, see GitHub's documentation on SSH, which is largely applies to any Git host.

If you use a third-party application to manage your SSH keys, you may need to perform a one-time setup to give Retcon access to these keys.

1Password

As of Retcon 1.3, you don't need to perform Retcon-specific setup to use 1Password as your SSH agent.

For help with setting up 1Password as an SSH agent, see the “Get started with 1Password for SSH” guide from the app's documentation.

Secretive

To allow Retcon to communicate with the Secretive SSH agent, follow the VS Code instructions from the Secretive FAQ.

Other agents

For help with using an SSH agent not mentioned in this guide, please contact us.