medkit

MEDKIT

MEDKIT (Multi-Environment Dotfiles Kit) is the dotfile management solution for the obsessive compulsive.

Complete Command List

commands

Overview

MEDKIT is a tool to help you take control of your local environment configuration including:

• Dotfile Management
• Run Command (rc) Script Management
• PATH Variable Management
• Software Installation

MEDKIT also has a native concept of environments which allow you to categorize your settings to match the systems you're using. This lets you customize each environment with ease.

Manage Your Dotfiles

The trouble with dotfiles is that, unless you have just one login on one computer, you'll have lots of them spread all over the place. If you're like most people, you want your preferences and configuration to be consistent no matter where you log in.

MEDKIT follows a "Write Once, Use Anywhere" philosophy. With a little help from your favorite version control tool, you can keep a "master" copy of your dotfiles and apply them anywhere you go.

• Install the dotfiles in your repository
• Scan for new dotfiles
• Add dotfiles to your repository

Organize Your Startup

Startup files often start simple, but turn into a nightmare to manage. It gets worse when tools and installers try to be helpful and make changes to them without asking. You can take advantage of MEDKIT's version control integration and templates to get your startup scripts under control once and for all.

• Start with the MEDKIT template or roll your own
• Run *.source scripts at startup

Organize Your PATH

Much like startup scripts, keeping your environment's PATH in order can be a real challenge. MEDKIT's convention-based system can help!

• Run *.path scripts
• Determine the order of each PATH element

Install Your Software

Getting all your tools installed is often one of the biggest challenges when you start using a new computer for the first time. With MEDKIT, you can script your installation scripts and run them as-needed.

• Run *.installer scripts
• Remember what has already been run
• Reset if needed

Environments

MEDKIT allows you to define one or more environments, but right now it's a big mystery.

Installation

macOS:

TBD

Linux:

TBD

Windows WSL:

TBD

Usage

Dotfiles structure

MEDKIT operates on a convention-based directory structure consisting of a root, and N bundle directories:

dotfiles/
├ bundles
│   ├ go
│   │   ├ Brewfile
│   │   └ path.sh
│   └ macos
│       └ Brewfile
├ homebrew
│   └ Brewfile
├ vim
│   └ .vimrc.symlink
└ zsh
    ├ install.sh
        └ .zshrc.symlink

Files you intend to share across all systems should be organized at the root level of your dotfile directory.

Files that you only want to use on some systems can be organized under the bundles directory. Each directory under bundles/ will act as a bundle, and can be optionally installed by specifying it at the command line, or in the .medkit config file.

In the example directory structure above, you can see 3 instances of the Brewfile. homebrew/Brewfile exists at the root level, and will install software every time medkit is run. Under the bundles directory, there is a Brewfile for the go bundle, and another for the macos bundle. The latter two brewfiles will only be run if specifically requested.

Initialization

First, we need to set up a ~/.medkit config file specifying the location of our dotfiles (defaults to ~/dotfiles), and any bundles we would like to enable on this machine.

dotfiles-directory: /home/marvin/dotfiles
active-bundles: [go,macos]

If you already have a dotfiles repo, clone it into dotfiles directory specified in your config file, and ensure that it follows the conventions described above.

If you do not yet have your own dotfiles, let medkit help you create one. Create and init your dotfiles directory:

mkdir /home/marvin/dotfiles
medkit init

TODO: Adding Dotfiles

Now, let's add an existing dotfile to MEDKIT. Of course, you'll replace the example path shown below with something real on your computer.

medkit add dotfile -f /home/marvin/.vimrc -d vim

This command will:

• Create a new folder in your dotfiles repo (if it doesn't already exist) named vim
• Move the specified dotfile into the folder
• Symlink the dotfile back to the original location

You can view all of the dotfiles MEDKIT is managing like this.

medkit get dotfiles

At this point you're ready to make your repo available in your other environments. MEDKIT is agnostic when it comes to how you do this, but using something like GitHub is highly recommended.

TODO: Provide basic GitHub instructions.

Install Dotfiles

With your MEDKIT repo now under version control, you can use your repo anywhere. Let's say you have a new computer. Just clone your GitHub repository to the new computer and install your dotfiles.

medkit install dotfiles

That's it!

Updating Dotfiles

When you make a change to a dotfile, you'll probably want to make that change available on all your computers. The specifics of how to synchronize your MEDKIT repo will depend on the tools you choose. If you're using GitHub, for example, you'll need to make your changes, push them to GitHub, then pull them on all your other computers. No matter which process you prefer, your dotfiles will be automatically updated.

How to Contribute

Contributions are welcome! Check out this link on how you can help!

Release History

MEDKIT's full release history can be found here.

Credits

• Zach Holman and his excellent "dotfiles are meant to be forked" blog post

License

Distributed under the MIT license. See the LICENSE file for more information.